@holo-js/config 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,219 @@
+import { NormalizedHoloQueueConfig, HoloQueueConfig } from '@holo-js/queue';
+export { HoloQueueConfig, NormalizedHoloQueueConfig } from '@holo-js/queue';
+
+interface HoloProjectPaths {
+    models: string;
+    migrations: string;
+    generatedSchema: string;
+    seeders: string;
+    observers: string;
+    factories: string;
+    commands: string;
+    jobs: string;
+}
+interface HoloProjectConnectionConfig {
+    driver?: SupportedDatabaseDriver;
+    url?: string;
+    host?: string;
+    port?: number | string;
+    username?: string;
+    password?: string;
+    database?: string;
+    filename?: string;
+    schema?: string;
+    ssl?: boolean | Record<string, unknown>;
+    logging?: boolean;
+}
+interface HoloProjectDatabaseConfig {
+    defaultConnection?: string;
+    connections?: Record<string, HoloProjectConnectionConfig | string>;
+}
+interface HoloProjectConfig {
+    paths?: Partial<HoloProjectPaths>;
+    database?: HoloProjectDatabaseConfig;
+    models?: readonly string[];
+    migrations?: readonly string[];
+    seeders?: readonly string[];
+}
+type SupportedDatabaseDriver = 'sqlite' | 'postgres' | 'mysql';
+type HoloAppEnv = 'development' | 'production' | 'test';
+interface HoloAppConfig extends HoloProjectConfig {
+    name?: string;
+    key?: string;
+    url?: string;
+    debug?: boolean;
+    env?: HoloAppEnv;
+}
+type HoloDatabaseConnectionConfig = HoloProjectConnectionConfig;
+type HoloDatabaseConfig = HoloProjectDatabaseConfig;
+type StorageDriver = 'local' | 'public' | 's3';
+type StorageVisibility = 'private' | 'public';
+interface BaseDiskConfig {
+    driver: StorageDriver;
+    visibility?: StorageVisibility;
+    root?: string;
+    url?: string;
+    [key: string]: unknown;
+}
+interface LocalDiskConfig extends BaseDiskConfig {
+    driver: 'local' | 'public';
+}
+interface S3DiskConfig extends BaseDiskConfig {
+    driver: 's3';
+    bucket?: string;
+    region?: string;
+    endpoint?: string;
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+    forcePathStyleEndpoint?: boolean;
+}
+type DiskConfig = LocalDiskConfig | S3DiskConfig;
+interface HoloStorageConfig {
+    defaultDisk?: string;
+    routePrefix?: string;
+    disks?: Record<string, DiskConfig>;
+}
+interface HoloMediaConfig {
+    [key: string]: unknown;
+}
+
+interface NormalizedHoloAppConfig {
+    readonly name: string;
+    readonly key: string;
+    readonly url: string;
+    readonly debug: boolean;
+    readonly env: HoloAppEnv;
+    readonly paths: Readonly<HoloProjectPaths>;
+    readonly models: readonly string[];
+    readonly migrations: readonly string[];
+    readonly seeders: readonly string[];
+}
+interface NormalizedHoloDatabaseConfig {
+    readonly defaultConnection?: string;
+    readonly connections: Readonly<Record<string, HoloDatabaseConnectionConfig | string>>;
+}
+interface NormalizedHoloStorageConfig {
+    readonly defaultDisk?: string;
+    readonly routePrefix: string;
+    readonly disks: Readonly<Record<string, DiskConfig>>;
+}
+interface HoloConfigRegistry {
+    app: NormalizedHoloAppConfig;
+    database: NormalizedHoloDatabaseConfig;
+    storage: NormalizedHoloStorageConfig;
+    queue: NormalizedHoloQueueConfig;
+    media: HoloMediaConfig;
+}
+type HoloConfigMap = object;
+interface LoadedEnvironment {
+    readonly name: HoloAppEnv;
+    readonly values: Readonly<Record<string, string>>;
+    readonly loadedFiles: readonly string[];
+    readonly warnings: readonly string[];
+}
+interface LoadedHoloConfig<TCustom extends HoloConfigMap = HoloConfigMap> {
+    readonly app: NormalizedHoloAppConfig;
+    readonly database: NormalizedHoloDatabaseConfig;
+    readonly storage: NormalizedHoloStorageConfig;
+    readonly queue: NormalizedHoloQueueConfig;
+    readonly media: HoloMediaConfig;
+    readonly custom: Readonly<TCustom>;
+    readonly all: Readonly<HoloConfigRegistry & TCustom>;
+    readonly environment: LoadedEnvironment;
+    readonly loadedFiles: readonly string[];
+    readonly warnings: readonly string[];
+}
+type ConfigFileName = keyof HoloConfigRegistry | (string & {});
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type NonTraversable = Primitive | readonly unknown[] | ((...args: never[]) => unknown);
+type KnownPathKey<T> = Extract<{
+    [K in keyof T]: K extends string ? string extends K ? never : K : never;
+}[keyof T], string>;
+type DotPath<T> = T extends NonTraversable ? never : {
+    [K in KnownPathKey<T>]: T[K] extends NonTraversable ? K : T[K] extends object ? K | `${K}.${DotPath<T[K]>}` : K;
+}[KnownPathKey<T>];
+type ValueAtPath<T, TPath extends string> = TPath extends `${infer Head}.${infer Tail}` ? Head extends keyof T ? ValueAtPath<T[Head], Tail> : never : TPath extends keyof T ? T[TPath] : never;
+type DefineConfigValue<TConfig extends object> = Readonly<TConfig>;
+
+declare const DEFAULT_APP_NAME = "Holo";
+declare const holoAppDefaults: Readonly<NormalizedHoloAppConfig>;
+declare const holoDatabaseDefaults: Readonly<NormalizedHoloDatabaseConfig>;
+declare const holoStorageDefaults: Readonly<NormalizedHoloStorageConfig>;
+declare const holoQueueDefaultsNormalized: Readonly<NormalizedHoloQueueConfig>;
+declare function normalizeAppEnv(value: string | undefined, fallback?: HoloAppEnv): HoloAppEnv;
+declare function normalizeAppConfig(config?: HoloAppConfig): NormalizedHoloAppConfig;
+declare function normalizeDatabaseConfig(config?: HoloDatabaseConfig): NormalizedHoloDatabaseConfig;
+declare function normalizeStorageConfig(config?: HoloStorageConfig): NormalizedHoloStorageConfig;
+declare function normalizeQueueConfigForHolo(config?: HoloQueueConfig): NormalizedHoloQueueConfig;
+
+type RuntimeConfigMap = HoloConfigRegistry & HoloConfigMap;
+type UseConfigAccessor<TConfig extends RuntimeConfigMap> = {
+    <TKey extends Extract<keyof TConfig, string>>(key: TKey): TConfig[TKey];
+    <TPath extends DotPath<TConfig>>(path: TPath): ValueAtPath<TConfig, TPath>;
+    (path: string): unknown;
+};
+type ConfigAccessor<TConfig extends RuntimeConfigMap> = {
+    <TPath extends DotPath<TConfig>>(path: TPath): ValueAtPath<TConfig, TPath>;
+    (path: string): unknown;
+};
+declare function createConfigAccessors<TConfig extends RuntimeConfigMap>(configMap: TConfig): {
+    useConfig: UseConfigAccessor<TConfig>;
+    config: ConfigAccessor<TConfig>;
+};
+declare function configureConfigRuntime<TConfig extends RuntimeConfigMap>(configMap: TConfig): void;
+declare function resetConfigRuntime(): void;
+declare function useConfig<TKey extends Extract<keyof RuntimeConfigMap, string>>(key: TKey): RuntimeConfigMap[TKey];
+declare function useConfig<TPath extends DotPath<RuntimeConfigMap>>(path: TPath): ValueAtPath<RuntimeConfigMap, TPath>;
+declare function useConfig(path: string): unknown;
+declare function config<TPath extends DotPath<RuntimeConfigMap>>(path: TPath): ValueAtPath<RuntimeConfigMap, TPath>;
+declare function config(path: string): unknown;
+
+type EnvScalar = string | number | boolean;
+type LoadEnvironmentOptions = {
+    cwd: string;
+    envName?: string;
+    processEnv?: NodeJS.ProcessEnv;
+};
+type EnvRuntimeMode = 'resolve' | 'capture';
+type EnvPlaceholder = {
+    readonly __holoEnv: true;
+    readonly key: string;
+    readonly fallback?: EnvScalar;
+};
+declare function resolveAppEnvironment(processEnv?: NodeJS.ProcessEnv): HoloAppEnv;
+declare function resolveEnvironmentFileOrder(envName: HoloAppEnv): string[];
+declare function loadEnvironment(options: LoadEnvironmentOptions): Promise<LoadedEnvironment>;
+declare function configureEnvRuntime(values?: Readonly<Record<string, string>>, options?: {
+    mode?: EnvRuntimeMode;
+}): void;
+declare function env(key: string): string;
+declare function env<TValue extends EnvScalar>(key: string, fallback: TValue): TValue;
+declare function isEnvPlaceholder(value: unknown): value is EnvPlaceholder;
+declare function resolveEnvPlaceholders<TValue>(value: TValue, envValues: Readonly<Record<string, string>>): TValue;
+
+declare function resolveConfigExport<TConfig extends object>(moduleValue: unknown): TConfig;
+declare function getConfigExtensionPriority(fileName: string): number;
+declare function resolveConfigCachePath(projectRoot: string): string;
+declare function writeConfigCache(projectRoot: string, options?: {
+    envName?: string;
+    processEnv?: NodeJS.ProcessEnv;
+}): Promise<string>;
+declare function clearConfigCache(projectRoot: string): Promise<boolean>;
+declare function loadConfigDirectory<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, options?: {
+    envName?: string;
+    processEnv?: NodeJS.ProcessEnv;
+    preferCache?: boolean;
+}): Promise<LoadedHoloConfig<TCustom>>;
+declare function defineConfig<TConfig extends object>(config: TConfig): DefineConfigValue<TConfig>;
+declare function defineAppConfig<TConfig extends HoloAppConfig>(config: TConfig): DefineConfigValue<TConfig>;
+declare function defineDatabaseConfig<TConfig extends HoloDatabaseConfig>(config: TConfig): DefineConfigValue<TConfig>;
+declare function defineStorageConfig<TConfig extends HoloStorageConfig>(config: TConfig): DefineConfigValue<TConfig>;
+declare function defineQueueConfig<TConfig extends HoloQueueConfig>(config: TConfig): DefineConfigValue<TConfig>;
+declare function defineMediaConfig<TConfig extends HoloMediaConfig>(config: TConfig): DefineConfigValue<TConfig>;
+declare const loaderInternals: {
+    getConfigExtensionPriority: typeof getConfigExtensionPriority;
+    resolveConfigExport: typeof resolveConfigExport;
+};
+
+export { type ConfigFileName, DEFAULT_APP_NAME, type DefineConfigValue, type DiskConfig, type DotPath, type HoloAppConfig, type HoloAppEnv, type HoloConfigMap, type HoloConfigRegistry, type HoloDatabaseConfig, type HoloDatabaseConnectionConfig, type HoloMediaConfig, type HoloStorageConfig, type LoadedEnvironment, type LoadedHoloConfig, type NormalizedHoloAppConfig, type NormalizedHoloDatabaseConfig, type NormalizedHoloStorageConfig, type SupportedDatabaseDriver, type ValueAtPath, clearConfigCache, config, configureConfigRuntime, configureEnvRuntime, createConfigAccessors, defineAppConfig, defineConfig, defineDatabaseConfig, defineMediaConfig, defineQueueConfig, defineStorageConfig, env, holoAppDefaults, holoDatabaseDefaults, holoQueueDefaultsNormalized, holoStorageDefaults, isEnvPlaceholder, loadConfigDirectory, loadEnvironment, loaderInternals, normalizeAppConfig, normalizeAppEnv, normalizeDatabaseConfig, normalizeQueueConfigForHolo, normalizeStorageConfig, resetConfigRuntime, resolveAppEnvironment, resolveConfigCachePath, resolveEnvPlaceholders, resolveEnvironmentFileOrder, useConfig, writeConfigCache };

package/dist/index.mjs

@@ -0,0 +1,638 @@
+// src/defaults.ts
+import {
+  DEFAULT_HOLO_PROJECT_PATHS,
+  normalizeHoloProjectConfig
+} from "@holo-js/db";
+import {
+  normalizeQueueConfig,
+  holoQueueDefaults
+} from "@holo-js/queue";
+var DEFAULT_APP_NAME = "Holo";
+var holoAppDefaults = Object.freeze({
+  name: DEFAULT_APP_NAME,
+  key: "",
+  url: "http://localhost:3000",
+  debug: true,
+  env: "development",
+  paths: Object.freeze({ ...DEFAULT_HOLO_PROJECT_PATHS }),
+  models: Object.freeze([]),
+  migrations: Object.freeze([]),
+  seeders: Object.freeze([])
+});
+var holoDatabaseDefaults = Object.freeze({
+  defaultConnection: "default",
+  connections: Object.freeze({
+    default: Object.freeze({
+      driver: "sqlite",
+      url: "./data/database.sqlite",
+      schema: "public",
+      logging: false
+    })
+  })
+});
+var holoStorageDefaults = Object.freeze({
+  defaultDisk: "local",
+  routePrefix: "/storage",
+  disks: Object.freeze({
+    local: Object.freeze({
+      driver: "local",
+      root: "./storage/app"
+    }),
+    public: Object.freeze({
+      driver: "public",
+      root: "./storage/app/public",
+      visibility: "public"
+    })
+  })
+});
+var holoQueueDefaultsNormalized = holoQueueDefaults;
+function normalizeAppEnv(value, fallback = "development") {
+  if (!value) {
+    return fallback;
+  }
+  if (value === "development" || value === "production" || value === "test") {
+    return value;
+  }
+  return fallback;
+}
+function normalizeAppConfig(config2 = {}) {
+  const project = normalizeHoloProjectConfig(config2);
+  const rawDebug = config2.debug;
+  const debug = typeof rawDebug === "string" ? !["false", "0", "off", "no"].includes(rawDebug.trim().toLowerCase()) : config2.debug;
+  return Object.freeze({
+    name: config2.name ?? holoAppDefaults.name,
+    key: config2.key ?? holoAppDefaults.key,
+    url: config2.url ?? holoAppDefaults.url,
+    debug: debug ?? holoAppDefaults.debug,
+    env: normalizeAppEnv(config2.env, holoAppDefaults.env),
+    paths: project.paths,
+    models: project.models,
+    migrations: project.migrations,
+    seeders: project.seeders
+  });
+}
+function normalizeDatabaseConfig(config2 = {}) {
+  const configuredConnections = config2.connections;
+  const connections = configuredConnections && Object.keys(configuredConnections).length > 0 ? Object.freeze({ ...configuredConnections }) : holoDatabaseDefaults.connections;
+  const defaultConnection = config2.defaultConnection ?? Object.keys(connections)[0];
+  return Object.freeze({
+    /* v8 ignore next */
+    defaultConnection: defaultConnection ?? "default",
+    connections
+  });
+}
+function normalizeStorageConfig(config2 = {}) {
+  return Object.freeze({
+    defaultDisk: config2.defaultDisk ?? holoStorageDefaults.defaultDisk,
+    routePrefix: config2.routePrefix ?? holoStorageDefaults.routePrefix,
+    disks: Object.freeze({
+      ...holoStorageDefaults.disks,
+      ...config2.disks ?? {}
+    })
+  });
+}
+function normalizeQueueConfigForHolo(config2 = {}) {
+  return normalizeQueueConfig(config2);
+}
+
+// src/access.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getValueAtPath(source, path) {
+  let current = source;
+  for (const segment of path.split(".")) {
+    if (!isObject(current) || !(segment in current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function createConfigAccessors(configMap) {
+  const useConfig2 = ((path) => {
+    return getValueAtPath(configMap, path);
+  });
+  const config2 = ((path) => {
+    return getValueAtPath(configMap, path);
+  });
+  return {
+    useConfig: useConfig2,
+    config: config2
+  };
+}
+function getRuntimeConfigState() {
+  const runtime = globalThis;
+  runtime.__holoConfigRuntime__ ??= {};
+  return runtime.__holoConfigRuntime__;
+}
+function configureConfigRuntime(configMap) {
+  getRuntimeConfigState().config = configMap;
+}
+function resetConfigRuntime() {
+  getRuntimeConfigState().config = void 0;
+}
+function requireConfigRuntime() {
+  const runtimeConfigMap = getRuntimeConfigState().config;
+  if (!runtimeConfigMap) {
+    throw new Error("Holo config runtime is not configured.");
+  }
+  return runtimeConfigMap;
+}
+function useConfig(path) {
+  return createConfigAccessors(requireConfigRuntime()).useConfig(path);
+}
+function config(path) {
+  return createConfigAccessors(requireConfigRuntime()).config(path);
+}
+
+// src/env.ts
+import { basename, join, resolve } from "path";
+import { readFile } from "fs/promises";
+function parseEnvFile(contents) {
+  const values = {};
+  for (const line of contents.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const exportPrefix = trimmed.startsWith("export ") ? trimmed.slice(7) : trimmed;
+    const separator = exportPrefix.indexOf("=");
+    if (separator <= 0) {
+      continue;
+    }
+    const key = exportPrefix.slice(0, separator).trim();
+    let value = exportPrefix.slice(separator + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    value = value.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	");
+    values[key] = value;
+  }
+  return values;
+}
+async function readEnvFile(filePath) {
+  try {
+    const contents = await readFile(filePath, "utf8");
+    return parseEnvFile(contents);
+  } catch {
+    return void 0;
+  }
+}
+function resolveAppEnvironment(processEnv = process.env) {
+  const value = processEnv.HOLO_ENV ?? processEnv.APP_ENV ?? processEnv.NODE_ENV;
+  if (value === "production" || value === "development" || value === "test") {
+    return value;
+  }
+  return "development";
+}
+function resolveEnvironmentFileOrder(envName) {
+  if (envName === "production") {
+    return [".env", ".env.production", ".env.prod", ".env.local"];
+  }
+  if (envName === "test") {
+    return [".env", ".env.test"];
+  }
+  return [".env", ".env.development", ".env.local"];
+}
+async function loadEnvironment(options) {
+  const cwd = resolve(options.cwd);
+  const envName = options.envName ? resolveAppEnvironment({ ...options.processEnv, HOLO_ENV: options.envName }) : resolveAppEnvironment(options.processEnv);
+  const loadedFiles = [];
+  const warnings = [];
+  const values = {};
+  const productionFileNames = /* @__PURE__ */ new Set();
+  for (const relativeName of resolveEnvironmentFileOrder(envName)) {
+    const filePath = join(cwd, relativeName);
+    const fileValues = await readEnvFile(filePath);
+    if (!fileValues) {
+      continue;
+    }
+    loadedFiles.push(filePath);
+    if (envName === "production" && (relativeName === ".env.production" || relativeName === ".env.prod")) {
+      productionFileNames.add(relativeName);
+    }
+    if (envName === "production" && relativeName === ".env.prod" && productionFileNames.has(".env.production")) {
+      warnings.push(`Ignoring ${basename(filePath)} because .env.production is present.`);
+      continue;
+    }
+    Object.assign(values, fileValues);
+  }
+  const processEnv = options.processEnv ?? process.env;
+  for (const [key, value] of Object.entries(processEnv)) {
+    if (typeof value === "string") {
+      values[key] = value;
+    }
+  }
+  return {
+    name: envName,
+    values: Object.freeze({ ...values }),
+    loadedFiles: Object.freeze([...loadedFiles]),
+    warnings: Object.freeze([...warnings])
+  };
+}
+function getEnvRuntimeState() {
+  const runtime = globalThis;
+  runtime.__holoEnvRuntime__ ??= {
+    mode: "resolve"
+  };
+  return runtime.__holoEnvRuntime__;
+}
+function configureEnvRuntime(values, options = {}) {
+  const state = getEnvRuntimeState();
+  state.values = values;
+  state.mode = options.mode ?? "resolve";
+}
+function coerceEnvScalar(runtimeValue, fallback) {
+  if (typeof fallback === "boolean") {
+    const normalized = runtimeValue.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") {
+      return false;
+    }
+    return fallback;
+  }
+  if (typeof fallback === "number") {
+    const parsed = Number(runtimeValue);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return runtimeValue;
+}
+function env(key, fallback) {
+  const state = getEnvRuntimeState();
+  if (process.env.HOLO_CAPTURE_ENV === "1" || state.mode === "capture") {
+    return Object.freeze({
+      __holoEnv: true,
+      key,
+      ...typeof fallback !== "undefined" ? { fallback } : {}
+    });
+  }
+  const runtimeValue = state.values?.[key];
+  if (typeof runtimeValue === "string") {
+    return typeof fallback === "undefined" ? runtimeValue : coerceEnvScalar(runtimeValue, fallback);
+  }
+  const processValue = process.env[key];
+  if (typeof processValue === "string") {
+    return typeof fallback === "undefined" ? processValue : coerceEnvScalar(processValue, fallback);
+  }
+  if (typeof fallback !== "undefined") {
+    return fallback;
+  }
+  return "";
+}
+function isEnvPlaceholder(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && value.__holoEnv === true && typeof value.key === "string";
+}
+function resolveEnvPlaceholders(value, envValues) {
+  if (isEnvPlaceholder(value)) {
+    const runtimeValue = envValues[value.key];
+    if (typeof runtimeValue === "string") {
+      if (typeof value.fallback === "undefined") {
+        return runtimeValue;
+      }
+      return coerceEnvScalar(runtimeValue, value.fallback);
+    }
+    if (typeof value.fallback !== "undefined") {
+      return value.fallback;
+    }
+    return "";
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => resolveEnvPlaceholders(entry, envValues));
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, resolveEnvPlaceholders(entry, envValues)])
+    );
+  }
+  return value;
+}
+
+// src/loader.ts
+import { mkdir, readFile as readFile2, readdir, rm, writeFile } from "fs/promises";
+import { dirname, extname, join as join2, resolve as resolve2 } from "path";
+import { pathToFileURL } from "url";
+var CONFIG_EXTENSION_PRIORITY = [".ts", ".mts", ".js", ".mjs", ".cts", ".cjs"];
+var SUPPORTED_CONFIG_EXTENSIONS = new Set(CONFIG_EXTENSION_PRIORITY);
+var HOLO_CONFIG_CACHE_VERSION = 1;
+var HOLO_CONFIG_CACHE_PATH = join2(".holo-js", "generated", "config-cache.json");
+var TRANSIENT_CONFIG_IMPORT_MARKER = ".__holo_import_";
+var LEGACY_TRANSIENT_CONFIG_IMPORT_MARKERS = [TRANSIENT_CONFIG_IMPORT_MARKER, ".__native_test__"];
+var USE_TRANSIENT_IMPORTS = process.env.VITEST === "true" || process.env.VITEST === "1";
+function isObject2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function resolveConfigExport(moduleValue) {
+  if (isObject2(moduleValue) && isObject2(moduleValue.default)) {
+    return moduleValue.default;
+  }
+  if (isObject2(moduleValue) && isObject2(moduleValue.config)) {
+    return moduleValue.config;
+  }
+  if (isObject2(moduleValue) && ("default" in moduleValue || "config" in moduleValue)) {
+    return {};
+  }
+  if (isObject2(moduleValue)) {
+    return moduleValue;
+  }
+  return {};
+}
+function getConfigName(fileName) {
+  return fileName.slice(0, fileName.length - extname(fileName).length);
+}
+var configImportNonce = 0;
+async function importConfigModule(filePath) {
+  configImportNonce += 1;
+  if (USE_TRANSIENT_IMPORTS) {
+    const extension = extname(filePath);
+    const transientPath = `${filePath.slice(0, filePath.length - extension.length)}${TRANSIENT_CONFIG_IMPORT_MARKER}${configImportNonce}${extension}`;
+    const source = await readFile2(filePath, "utf8");
+    await writeFile(transientPath, source, "utf8");
+    try {
+      return await import(
+        /* webpackIgnore: true */
+        pathToFileURL(transientPath).href
+      );
+    } finally {
+      await rm(transientPath, { force: true });
+    }
+  }
+  return import(
+    /* webpackIgnore: true */
+    `${pathToFileURL(filePath).href}?t=${configImportNonce}`
+  );
+}
+async function writeFileIfChanged(filePath, contents) {
+  const existing = await readFile2(filePath, "utf8").catch(() => void 0);
+  if (existing === contents) {
+    return;
+  }
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, contents, "utf8");
+}
+function getConfigExtensionPriority(fileName) {
+  const extension = extname(fileName);
+  const index = CONFIG_EXTENSION_PRIORITY.indexOf(extension);
+  return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+}
+async function collectConfigEntries(configDir) {
+  const entries = await readdir(configDir, { withFileTypes: true }).catch(() => []);
+  const selectedByName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (LEGACY_TRANSIENT_CONFIG_IMPORT_MARKERS.some((marker) => entry.name.includes(marker))) {
+      if (!USE_TRANSIENT_IMPORTS) {
+        await rm(join2(configDir, entry.name), { force: true });
+      }
+      continue;
+    }
+    const extension = extname(entry.name);
+    if (!SUPPORTED_CONFIG_EXTENSIONS.has(extension)) {
+      continue;
+    }
+    const configName = getConfigName(entry.name);
+    const filePath = join2(configDir, entry.name);
+    const priority = getConfigExtensionPriority(entry.name);
+    const current = selectedByName.get(configName);
+    if (!current || priority < current.priority) {
+      selectedByName.set(configName, { filePath, priority });
+    }
+  }
+  return [...selectedByName.entries()].sort((left, right) => left[0].localeCompare(right[0])).map(([configName, entry]) => ({
+    configName,
+    filePath: entry.filePath
+  }));
+}
+async function collectRawConfig(configDir, environmentValues, options = {}) {
+  const rawConfig = {};
+  const loadedFiles = [];
+  const configEntries = await collectConfigEntries(configDir);
+  const previousEnvEntries = /* @__PURE__ */ new Map();
+  try {
+    configureEnvRuntime(environmentValues, {
+      mode: options.captureEnvPlaceholders ? "capture" : "resolve"
+    });
+    for (const [key, value] of Object.entries(environmentValues)) {
+      previousEnvEntries.set(key, process.env[key]);
+      process.env[key] = value;
+    }
+    previousEnvEntries.set("HOLO_CAPTURE_ENV", process.env.HOLO_CAPTURE_ENV);
+    if (options.captureEnvPlaceholders) {
+      process.env.HOLO_CAPTURE_ENV = "1";
+    } else {
+      Reflect.deleteProperty(process.env, "HOLO_CAPTURE_ENV");
+    }
+    for (const entry of configEntries) {
+      rawConfig[entry.configName] = resolveConfigExport(await importConfigModule(entry.filePath));
+      loadedFiles.push(entry.filePath);
+    }
+  } finally {
+    configureEnvRuntime(void 0);
+    for (const [key, value] of previousEnvEntries) {
+      if (typeof value === "string") {
+        process.env[key] = value;
+        continue;
+      }
+      Reflect.deleteProperty(process.env, key);
+    }
+  }
+  return {
+    rawConfig,
+    loadedFiles: Object.freeze([...loadedFiles])
+  };
+}
+function normalizeLoadedConfig(rawConfig, options) {
+  const resolvedRawConfig = resolveEnvPlaceholders(rawConfig, options.environment.values);
+  const app = normalizeAppConfig(resolvedRawConfig.app);
+  const database = normalizeDatabaseConfig(resolvedRawConfig.database);
+  const storage = normalizeStorageConfig(resolvedRawConfig.storage);
+  const queue = normalizeQueueConfigForHolo(resolvedRawConfig.queue);
+  const media = Object.freeze({ ...resolvedRawConfig.media ?? {} });
+  const customEntries = Object.entries(resolvedRawConfig).filter(([key]) => {
+    return key !== "app" && key !== "database" && key !== "storage" && key !== "queue" && key !== "media";
+  });
+  const custom = Object.freeze(Object.fromEntries(customEntries));
+  const all = Object.freeze({
+    app,
+    database,
+    storage,
+    queue,
+    media,
+    ...custom
+  });
+  return {
+    app,
+    database,
+    storage,
+    queue,
+    media,
+    custom,
+    all,
+    environment: options.environment,
+    loadedFiles: Object.freeze([...options.loadedFiles]),
+    warnings: options.environment.warnings
+  };
+}
+function isSerializableConfigValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.every((entry) => isSerializableConfigValue(entry));
+  }
+  if (isObject2(value)) {
+    return Object.values(value).every((entry) => isSerializableConfigValue(entry));
+  }
+  return false;
+}
+function assertSerializableConfig(rawConfig) {
+  if (!isSerializableConfigValue(rawConfig)) {
+    throw new TypeError("Holo config cache only supports plain JSON-serializable config values.");
+  }
+}
+function isCachePayload(value) {
+  return isObject2(value) && value.version === HOLO_CONFIG_CACHE_VERSION && isObject2(value.environment) && typeof value.environment.name === "string" && Array.isArray(value.environment.loadedFiles) && Array.isArray(value.environment.warnings) && Array.isArray(value.configFiles) && isObject2(value.config);
+}
+function resolveConfigCachePath(projectRoot) {
+  return join2(resolve2(projectRoot), HOLO_CONFIG_CACHE_PATH);
+}
+async function readConfigCache(projectRoot) {
+  const cachePath = resolveConfigCachePath(projectRoot);
+  const contents = await readFile2(cachePath, "utf8").catch(() => void 0);
+  if (!contents) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(contents);
+    return isCachePayload(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function writeConfigCache(projectRoot, options = {}) {
+  const root = resolve2(projectRoot);
+  const configDir = join2(root, "config");
+  const environment = await loadEnvironment({
+    cwd: root,
+    envName: options.envName,
+    processEnv: options.processEnv
+  });
+  const { rawConfig, loadedFiles } = await collectRawConfig(configDir, environment.values, {
+    captureEnvPlaceholders: true
+  });
+  assertSerializableConfig(rawConfig);
+  const cachePath = resolveConfigCachePath(root);
+  const contents = `${JSON.stringify({
+    version: HOLO_CONFIG_CACHE_VERSION,
+    environment: {
+      name: environment.name,
+      loadedFiles: environment.loadedFiles,
+      warnings: environment.warnings
+    },
+    configFiles: loadedFiles,
+    config: rawConfig
+  }, null, 2)}
+`;
+  await writeFileIfChanged(cachePath, contents);
+  return cachePath;
+}
+async function clearConfigCache(projectRoot) {
+  const cachePath = resolveConfigCachePath(projectRoot);
+  const exists = await readFile2(cachePath, "utf8").then(() => true).catch(() => false);
+  if (!exists) {
+    return false;
+  }
+  await rm(cachePath, { force: true });
+  return true;
+}
+async function loadConfigDirectory(projectRoot, options = {}) {
+  const root = resolve2(projectRoot);
+  const configDir = join2(root, "config");
+  const envName = options.envName ? resolveAppEnvironment({ ...options.processEnv, HOLO_ENV: options.envName }) : resolveAppEnvironment(options.processEnv);
+  const preferCache = options.preferCache ?? envName === "production";
+  if (preferCache) {
+    const cached = await readConfigCache(root);
+    if (cached?.environment.name === envName) {
+      const environment2 = await loadEnvironment({
+        cwd: root,
+        envName,
+        processEnv: options.processEnv
+      });
+      return normalizeLoadedConfig(cached.config, {
+        environment: environment2,
+        loadedFiles: cached.configFiles
+      });
+    }
+  }
+  const environment = await loadEnvironment({
+    cwd: root,
+    envName,
+    processEnv: options.processEnv
+  });
+  const { rawConfig, loadedFiles } = await collectRawConfig(configDir, environment.values);
+  return normalizeLoadedConfig(rawConfig, {
+    environment,
+    loadedFiles
+  });
+}
+function defineConfig(config2) {
+  return Object.freeze({ ...config2 });
+}
+function defineAppConfig(config2) {
+  return defineConfig(config2);
+}
+function defineDatabaseConfig(config2) {
+  return defineConfig(config2);
+}
+function defineStorageConfig(config2) {
+  return defineConfig(config2);
+}
+function defineQueueConfig(config2) {
+  return defineConfig(config2);
+}
+function defineMediaConfig(config2) {
+  return defineConfig(config2);
+}
+var loaderInternals = {
+  getConfigExtensionPriority,
+  resolveConfigExport
+};
+export {
+  DEFAULT_APP_NAME,
+  clearConfigCache,
+  config,
+  configureConfigRuntime,
+  configureEnvRuntime,
+  createConfigAccessors,
+  defineAppConfig,
+  defineConfig,
+  defineDatabaseConfig,
+  defineMediaConfig,
+  defineQueueConfig,
+  defineStorageConfig,
+  env,
+  holoAppDefaults,
+  holoDatabaseDefaults,
+  holoQueueDefaultsNormalized,
+  holoStorageDefaults,
+  isEnvPlaceholder,
+  loadConfigDirectory,
+  loadEnvironment,
+  loaderInternals,
+  normalizeAppConfig,
+  normalizeAppEnv,
+  normalizeDatabaseConfig,
+  normalizeQueueConfigForHolo,
+  normalizeStorageConfig,
+  resetConfigRuntime,
+  resolveAppEnvironment,
+  resolveConfigCachePath,
+  resolveEnvPlaceholders,
+  resolveEnvironmentFileOrder,
+  useConfig,
+  writeConfigCache
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@holo-js/config",
+  "version": "0.1.0",
+  "description": "Holo-JS Framework - typed config loading, env layering, and runtime access",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "stub": "tsup",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest --run"
+  },
+  "dependencies": {
+    "@holo-js/db": "workspace:*",
+    "@holo-js/queue": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  }
+}