@autometa/config 0.1.27 → 1.0.0-rc.1

package/dist/index.js

@@ -1,172 +1,790 @@
-"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);
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Config: () => Config,
-  EnvironmentReader: () => EnvironmentReader,
-  defineConfig: () => defineConfig
-});
-module.exports = __toCommonJS(src_exports);
+import { AutomationError } from '@autometa/errors';
+import { posix } from 'node:path';
+import { z } from 'zod';
 
-// src/config-object.ts
-var import_errors = require("@autometa/errors");
+// src/config.ts
 
-// src/environment-reader.ts
-var _envVar, _factory, _literal;
-var EnvironmentReader = class {
+// src/environment-selector.ts
+var sanitize = (value) => {
+  if (value == null) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length === 0 ? void 0 : trimmed;
+};
+var EnvironmentSelector = class {
   constructor() {
-    __privateAdd(this, _envVar, void 0);
-    __privateAdd(this, _factory, void 0);
-    __privateAdd(this, _literal, void 0);
-  }
-  /**
-   * Returns the configuration object for the selected
-   * environment by weighting.
-   *
-   * By priority the environment is selected by:
-   * 1. Literal
-   * 2. Environment Variable
-   * 3. Factory
-   */
-  get value() {
-    if (__privateGet(this, _literal)) {
-      return __privateGet(this, _literal);
-    }
-    if (__privateGet(this, _envVar)) {
-      const value = process.env[__privateGet(this, _envVar)];
-      if (value) {
-        return value;
-      }
-    }
-    if (__privateGet(this, _factory)) {
-      return __privateGet(this, _factory).call(this);
-    }
+    this.detectors = [];
+    this.fallback = "default";
+  }
+  byLiteral(name) {
+    this.detectors.push(() => sanitize(name));
+    return this;
   }
-  byEnvironmentVariable(envVar) {
-    __privateSet(this, _envVar, envVar);
+  byEnvironmentVariable(variable) {
+    this.detectors.push(() => sanitize(process.env[variable]));
     return this;
   }
   byFactory(factory) {
-    __privateSet(this, _factory, factory);
+    this.detectors.push(() => sanitize(factory()));
     return this;
   }
-  byLiteral(literal) {
-    __privateSet(this, _literal, literal);
+  defaultTo(name) {
+    const sanitized = sanitize(name);
+    if (!sanitized) {
+      throw new Error("Default environment name must be a non-empty string");
+    }
+    this.fallback = sanitized;
     return this;
   }
+  resolve() {
+    for (const detector of this.detectors) {
+      const detected = detector();
+      if (detected) {
+        return detected;
+      }
+    }
+    return this.fallback;
+  }
 };
-_envVar = new WeakMap();
-_factory = new WeakMap();
-_literal = new WeakMap();
+var TimeUnitSchema = z.enum(["ms", "s", "m", "h"]);
+var TimeoutSchema = z.union([
+  z.number().nonnegative(),
+  z.tuple([z.number().nonnegative(), TimeUnitSchema]),
+  z.object({
+    value: z.number().nonnegative(),
+    unit: TimeUnitSchema.optional()
+  })
+]).optional();
+var RunnerSchema = z.union([z.literal("jest"), z.literal("vitest"), z.literal("playwright")]);
+var TagFilterSchema = z.string().refine(
+  (value) => value.startsWith("@") || value.startsWith("not @"),
+  "tag filter must start with `@` or `not @`"
+).optional();
+var TestSchema = z.object({
+  timeout: TimeoutSchema,
+  tagFilter: TagFilterSchema,
+  groupLogging: z.boolean().optional()
+}).partial();
+var ShimSchema = z.object({
+  errorCause: z.boolean().optional()
+});
+var PathSchema = z.array(z.string());
+var RootSchema = z.object({
+  features: PathSchema,
+  steps: PathSchema,
+  support: PathSchema.optional()
+}).catchall(PathSchema);
+var EventsSchema = z.array(z.string());
+var LoggingSchema = z.object({
+  http: z.boolean().optional()
+}).optional();
+var ReporterSchema = z.object({
+  hierarchical: z.object({
+    bufferOutput: z.boolean().optional()
+  }).optional()
+}).optional();
+var ModuleFormatSchema = z.enum(["cjs", "esm"]);
+var PartialRootSchema = RootSchema.partial();
+var ModuleDeclarationSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.object({
+      name: z.string().min(1),
+      submodules: z.array(ModuleDeclarationSchema).optional()
+    })
+  ])
+);
+var ModulesConfigSchema = z.object({
+  stepScoping: z.enum(["global", "scoped"]).optional(),
+  relativeRoots: PartialRootSchema.optional(),
+  groups: z.record(
+    z.object({
+      root: z.string(),
+      modules: z.array(ModuleDeclarationSchema).nonempty()
+    })
+  ).optional(),
+  explicit: z.array(z.string()).optional()
+});
+var SourceMapSchema = z.union([
+  z.literal(true),
+  z.literal(false),
+  z.literal("inline"),
+  z.literal("external")
+]);
+var BuildHookSchema = z.custom((value) => {
+  return typeof value === "function";
+}, {
+  message: "build hooks must be functions"
+});
+var BuilderHooksSchema = z.object({
+  before: z.array(BuildHookSchema).optional(),
+  after: z.array(BuildHookSchema).optional()
+});
+var BuilderConfigSchema = z.object({
+  format: ModuleFormatSchema.optional(),
+  target: z.union([z.string(), z.array(z.string()).nonempty()]).optional(),
+  sourcemap: SourceMapSchema.optional(),
+  tsconfig: z.string().optional(),
+  external: z.array(z.string()).optional(),
+  outDir: z.string().optional(),
+  hooks: BuilderHooksSchema.optional()
+});
+var ExecutorConfigSchema = z.object({
+  runner: RunnerSchema,
+  test: TestSchema.optional(),
+  roots: RootSchema,
+  modules: ModulesConfigSchema.optional(),
+  shim: ShimSchema.optional(),
+  events: EventsSchema.optional(),
+  builder: BuilderConfigSchema.optional(),
+  logging: LoggingSchema.optional(),
+  reporting: ReporterSchema.optional()
+});
+var PartialExecutorConfigSchema = z.object({
+  runner: RunnerSchema.optional(),
+  test: TestSchema.optional(),
+  roots: PartialRootSchema.optional(),
+  modules: ModulesConfigSchema.optional(),
+  shim: ShimSchema.optional(),
+  events: EventsSchema.optional(),
+  builder: BuilderConfigSchema.optional(),
+  logging: LoggingSchema.optional(),
+  reporting: ReporterSchema.optional()
+});
 
-// src/config-object.ts
+// src/config.ts
 var Config = class {
-  constructor(envMap) {
-    this.envMap = envMap;
-    this.environments = new EnvironmentReader();
-  }
-  get current() {
-    const key = this.environments.value;
-    if (!key) {
-      if (!this.envMap.has("default")) {
-        throw new import_errors.AutomationError(
-          `No environment is defined. Define an environment with 'env.byLiteral("my-environment")' or 'env.byEnvironmentVariable("MY_ENVIRONMENT")' or 'env.byFactory(() => "my-environment")' or 'env.byLiteral("default")'`
+  constructor(definition) {
+    this.definition = definition;
+  }
+  resolve(options = {}) {
+    const environment = this.resolveEnvironment(options);
+    const override = this.definition.environments[environment] ?? {};
+    const merged = mergeExecutorConfig(this.definition.default, override);
+    const validated = ExecutorConfigSchema.parse(merged);
+    const expanded = expandModules(validated, options.modules, options.groups);
+    return {
+      environment,
+      config: deepFreeze(expanded)
+    };
+  }
+  current(options) {
+    return this.resolve(options).config;
+  }
+  get environment() {
+    return this.resolve().environment;
+  }
+  forEnvironment(environment) {
+    return this.resolve({ environment }).config;
+  }
+  resolveEnvironment(options) {
+    if (options.environment) {
+      return this.assertEnvironment(options.environment);
+    }
+    const detected = this.definition.selector.resolve();
+    return this.assertEnvironment(detected);
+  }
+  assertEnvironment(environment) {
+    if (environment === "default") {
+      return environment;
+    }
+    if (!this.definition.environments[environment]) {
+      const available = [
+        "default",
+        ...Object.keys(this.definition.environments).filter(
+          (name) => name !== "default"
+        )
+      ];
+      const options = available.length ? available.join(", ") : "(define environments to extend the default profile)";
+      throw new AutomationError(
+        `Environment "${environment}" is not defined. Available environments: ${options}`
+      );
+    }
+    return environment;
+  }
+};
+var defineConfig = (input) => {
+  const selector = new EnvironmentSelector();
+  selector.defaultTo("default");
+  if (input.environment) {
+    input.environment(selector);
+  }
+  const defaultConfig = deepFreeze(ExecutorConfigSchema.parse(input.default));
+  const environments = {};
+  for (const [name, rawOverride] of Object.entries(input.environments ?? {})) {
+    if (!name.trim()) {
+      throw new AutomationError("Environment name must be a non-empty string");
+    }
+    const override = rawOverride ? PartialExecutorConfigSchema.parse(rawOverride) : {};
+    environments[name] = deepFreeze(override);
+  }
+  return new Config({
+    default: defaultConfig,
+    environments,
+    selector
+  });
+};
+var mergeExecutorConfig = (base, override) => {
+  const result = cloneConfig(base);
+  if (override.runner) {
+    result.runner = override.runner;
+  }
+  if (override.test !== void 0) {
+    result.test = mergeTest(result.test, override.test);
+  }
+  if (override.roots !== void 0) {
+    result.roots = mergeRoots(result.roots, override.roots);
+  }
+  if (override.modules !== void 0) {
+    result.modules = cloneModules(override.modules);
+  }
+  if (override.shim !== void 0) {
+    result.shim = mergeShim(result.shim, override.shim);
+  }
+  if (override.events !== void 0) {
+    result.events = cloneArray(override.events);
+  }
+  if (override.builder !== void 0) {
+    result.builder = mergeBuilder(result.builder, override.builder);
+  }
+  if (override.logging !== void 0) {
+    result.logging = mergeLogging(result.logging, override.logging);
+  }
+  if (override.reporting !== void 0) {
+    result.reporting = mergeReporting(result.reporting, override.reporting);
+  }
+  return result;
+};
+var expandModules = (config, moduleFilters, groupFilters) => {
+  const modulesConfig = config.modules;
+  if (!modulesConfig) {
+    return config;
+  }
+  const relativeRoots = modulesConfig.relativeRoots;
+  const hasRelativeRoots = !!relativeRoots && Object.keys(relativeRoots).length > 0;
+  if (!hasRelativeRoots) {
+    const hasFilters = (moduleFilters?.some((m) => m.trim().length > 0) ?? false) || (groupFilters?.some((g) => g.trim().length > 0) ?? false);
+    if (hasFilters) {
+      throw new AutomationError(
+        'Module filters were provided, but "modules.relativeRoots" is not configured. Configure at least one relative root (e.g. { steps: ["steps/**/*.ts"] }) or remove -m/-g.'
+      );
+    }
+    return config;
+  }
+  const moduleEntries = collectModuleEntries(modulesConfig);
+  if (moduleEntries.length === 0) {
+    throw new AutomationError(
+      'When "modules" is provided, at least one module must be declared via "groups" or "explicit".'
+    );
+  }
+  const selectedModules = selectModules(moduleEntries, moduleFilters, groupFilters);
+  const expandedByKey = {};
+  for (const [key, entries] of Object.entries(relativeRoots)) {
+    if (!entries || entries.length === 0) {
+      continue;
+    }
+    const expanded = [];
+    for (const moduleDir of selectedModules) {
+      for (const entry of entries) {
+        const joined = joinModuleEntry(moduleDir, entry);
+        if (joined) {
+          expanded.push(joined);
+        }
+      }
+    }
+    if (expanded.length > 0) {
+      expandedByKey[key] = expanded;
+    }
+  }
+  if (Object.keys(expandedByKey).length === 0) {
+    return config;
+  }
+  const roots = cloneRoots(config.roots);
+  for (const [key, expanded] of Object.entries(expandedByKey)) {
+    const existing = roots[key] ?? [];
+    roots[key] = [...expanded, ...existing];
+  }
+  return {
+    ...config,
+    roots
+  };
+};
+var flattenModuleDeclarations = (declarations, prefix = "") => {
+  const flattened = [];
+  const walk = (items, currentPrefix) => {
+    for (const item of items) {
+      if (typeof item === "string") {
+        const name2 = normalizeSlashes(item.trim()).replace(/^\/+|\/+$/gu, "");
+        if (!name2) {
+          continue;
+        }
+        flattened.push(normalizeSlashes(posix.join(currentPrefix, name2)));
+        continue;
+      }
+      const name = normalizeSlashes(item.name.trim()).replace(/^\/+|\/+$/gu, "");
+      if (!name) {
+        continue;
+      }
+      const nextPrefix = normalizeSlashes(posix.join(currentPrefix, name));
+      flattened.push(nextPrefix);
+      if (item.submodules && item.submodules.length > 0) {
+        walk(item.submodules, nextPrefix);
+      }
+    }
+  };
+  const cleanedPrefix = normalizeSlashes(prefix.trim()).replace(/\/+$/u, "");
+  walk(declarations, cleanedPrefix);
+  return Array.from(new Set(flattened));
+};
+var collectModuleEntries = (modulesConfig) => {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [groupId, group] of Object.entries(modulesConfig.groups ?? {})) {
+    const normalizedGroupId = groupId.trim();
+    if (!normalizedGroupId) {
+      continue;
+    }
+    const root = normalizeSlashes(group.root.trim()).replace(/\/+$/u, "");
+    if (!root) {
+      continue;
+    }
+    const modulePaths = flattenModuleDeclarations(group.modules);
+    for (const modulePath of modulePaths) {
+      const cleaned = normalizeSlashes(modulePath.trim()).replace(/^\/+|\/+$/gu, "");
+      if (!cleaned) {
+        continue;
+      }
+      const dir = normalizeSlashes(posix.join(root, cleaned));
+      const id = `${normalizedGroupId}/${cleaned}`;
+      const key = `${id}::${dir}`;
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      entries.push({ id, dir });
+    }
+  }
+  for (const explicit of modulesConfig.explicit ?? []) {
+    const normalized = normalizeSlashes(explicit.trim());
+    if (!normalized) {
+      continue;
+    }
+    const id = normalized;
+    const key = `${id}::${normalized}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    entries.push({ id, dir: normalized });
+  }
+  return entries;
+};
+var selectModules = (moduleEntries, moduleFilters, groupFilters) => {
+  const options = moduleEntries.map((m) => ({
+    id: normalizeSlashes(m.id),
+    dir: normalizeSlashes(m.dir),
+    group: normalizeSlashes(m.id.split("/")[0] ?? "")
+  }));
+  const groupFilterSet = new Set(
+    (groupFilters ?? []).map((g) => normalizeSlashes(g.trim())).filter(Boolean)
+  );
+  const inGroupScope = (candidate) => {
+    if (groupFilterSet.size === 0) {
+      return true;
+    }
+    return groupFilterSet.has(candidate.group);
+  };
+  const scopedOptions = options.filter(inGroupScope);
+  if (groupFilterSet.size > 0 && scopedOptions.length === 0) {
+    throw new AutomationError(
+      `No modules found for group filter(s): ${Array.from(groupFilterSet).join(", ")}. Available groups: ${Array.from(new Set(options.map((o) => o.group))).filter(Boolean).join(", ")}`
+    );
+  }
+  if (!moduleFilters || moduleFilters.length === 0) {
+    return scopedOptions.map((o) => o.dir);
+  }
+  const scopedGroups = new Set(scopedOptions.map((o) => o.group).filter(Boolean));
+  const selected = /* @__PURE__ */ new Set();
+  for (const rawFilter of moduleFilters) {
+    const filter = normalizeSlashes(rawFilter.trim());
+    if (!filter) {
+      continue;
+    }
+    const parsed = parseModuleSelector(filter, scopedGroups);
+    if (parsed) {
+      const wantedId = `${parsed.group}/${parsed.modulePath}`;
+      const exact = scopedOptions.filter((o) => o.id === wantedId);
+      if (exact.length === 0) {
+        throw new AutomationError(
+          `Module "${rawFilter}" not found. Available modules: ${scopedOptions.map((o) => o.id).join(", ")}`
         );
       }
-      return this.envMap.get("default");
-    }
-    if (!this.envMap.has(key)) {
-      throw new import_errors.AutomationError(
-        `Environment ${key} is not defined. Options are: 
- ${Object.keys(
-          this.envMap
-        ).join("\n")}`
+      const match2 = exact[0];
+      if (match2) {
+        selected.add(match2.dir);
+      }
+      continue;
+    }
+    const pathSelector = filter.includes(":") ? filter.split(":").join("/") : filter;
+    const suffixMatches = scopedOptions.filter((o) => o.id.endsWith(`/${pathSelector}`));
+    if (suffixMatches.length === 0) {
+      throw new AutomationError(
+        `Module "${rawFilter}" not found. Available modules: ${scopedOptions.map((o) => o.id).join(", ")}`
       );
     }
-    return this.envMap.get(key) ?? (0, import_errors.raise)(`Environment ${key} is not defined`);
+    if (suffixMatches.length > 1) {
+      throw new AutomationError(
+        `Module filter "${rawFilter}" is ambiguous. Candidates: ${suffixMatches.map((m) => m.id).join(", ")}. Use "<group>/<module>" or "<group>:<module>" to disambiguate.`
+      );
+    }
+    const match = suffixMatches[0];
+    if (match) {
+      selected.add(match.dir);
+    }
+  }
+  return scopedOptions.map((o) => o.dir).filter((dir) => selected.has(dir));
+};
+var parseModuleSelector = (selector, knownGroups) => {
+  if (!selector) {
+    return void 0;
+  }
+  if (selector.includes(":")) {
+    const parts = selector.split(":").map((p) => p.trim()).filter(Boolean);
+    if (parts.length >= 2) {
+      const group = parts[0];
+      if (!group) {
+        return void 0;
+      }
+      if (knownGroups.has(group)) {
+        const modulePath = normalizeSlashes(parts.slice(1).join("/")).replace(/^\/+|\/+$/gu, "");
+        if (modulePath) {
+          return { group, modulePath };
+        }
+      }
+    }
   }
-  get currentEnvironment() {
-    return this.environments.value;
+  if (selector.includes("/")) {
+    const parts = selector.split("/").map((p) => p.trim()).filter(Boolean);
+    if (parts.length >= 2) {
+      const group = parts[0];
+      if (!group) {
+        return void 0;
+      }
+      if (knownGroups.has(group)) {
+        const modulePath = normalizeSlashes(parts.slice(1).join("/")).replace(/^\/+|\/+$/gu, "");
+        if (modulePath) {
+          return { group, modulePath };
+        }
+      }
+    }
   }
+  return void 0;
 };
-
-// src/define-config.ts
-var import_errors2 = require("@autometa/errors");
-function defineConfig(config, ...configs) {
-  const envs = [];
-  const envMap = config.envMap;
-  for (const config2 of configs) {
-    if (config2.environment) {
-      if (envs.includes(config2.environment)) {
-        throw new import_errors2.AutomationError(
-          `Environment ${config2.environment} is defined more than once`
-        );
+var joinModuleEntry = (moduleDir, entry) => {
+  const moduleTrimmed = normalizeSlashes(moduleDir.trim()).replace(/\/+$/u, "");
+  if (!moduleTrimmed) {
+    return void 0;
+  }
+  const entryTrimmed = normalizeSlashes(entry.trim());
+  if (!entryTrimmed) {
+    return void 0;
+  }
+  const negated = entryTrimmed.startsWith("!");
+  const raw = negated ? entryTrimmed.slice(1).trim() : entryTrimmed;
+  if (!raw || raw === ".") {
+    return negated ? `!${moduleTrimmed}` : moduleTrimmed;
+  }
+  if (raw.startsWith("/") || /^[A-Za-z]:\//u.test(raw)) {
+    return negated ? `!${raw}` : raw;
+  }
+  const joined = normalizeSlashes(posix.join(moduleTrimmed, raw));
+  return negated ? `!${joined}` : joined;
+};
+var normalizeSlashes = (value) => value.replace(/\\/gu, "/");
+var mergeTest = (base, override) => {
+  if (override === void 0) {
+    return base ? cloneTest(base) : void 0;
+  }
+  const result = base ? cloneTest(base) : {};
+  if (override.timeout !== void 0) {
+    result.timeout = cloneTimeout(override.timeout);
+  }
+  if (override.tagFilter !== void 0) {
+    result.tagFilter = override.tagFilter;
+  }
+  if (override.groupLogging !== void 0) {
+    result.groupLogging = override.groupLogging;
+  }
+  return Object.keys(result).length === 0 ? void 0 : result;
+};
+var mergeShim = (base, override) => {
+  if (override === void 0) {
+    return base ? cloneShim(base) : void 0;
+  }
+  const result = base ? cloneShim(base) : {};
+  if (override.errorCause !== void 0) {
+    result.errorCause = override.errorCause;
+  }
+  return Object.keys(result).length === 0 ? void 0 : result;
+};
+var mergeLogging = (base, override) => {
+  if (override === void 0) {
+    return base ? cloneLogging(base) : void 0;
+  }
+  const result = base ? cloneLogging(base) : {};
+  if (override.http !== void 0) {
+    result.http = override.http;
+  }
+  return Object.keys(result).length === 0 ? void 0 : result;
+};
+var mergeReporting = (base, override) => {
+  if (override === void 0) {
+    return base ? cloneReporting(base) : void 0;
+  }
+  const result = base ? cloneReporting(base) : {};
+  if (override.hierarchical !== void 0) {
+    const hierarchicalOverride = override.hierarchical;
+    if (hierarchicalOverride) {
+      const hierarchical = result.hierarchical ? { ...result.hierarchical } : {};
+      if (hierarchicalOverride.bufferOutput !== void 0) {
+        hierarchical.bufferOutput = hierarchicalOverride.bufferOutput;
+      }
+      if (Object.keys(hierarchical).length > 0) {
+        result.hierarchical = hierarchical;
+      } else {
+        delete result.hierarchical;
       }
-      envMap.set(config2.environment, config2);
-      envs.push(config2.environment);
-    } else if (!config2.environment && envs.includes("default")) {
-      throw new import_errors2.AutomationError(`Only one default environment can be defined`);
     } else {
-      envMap.set("default", config2);
-      envs.push("default");
-      config2.environment = "default";
+      delete result.hierarchical;
     }
-    if (config2.shim) {
-      if ("error-cause" in config2.shim && config2.shim["error-cause"] === true) {
-        require("error-cause/auto");
-      }
+  }
+  return Object.keys(result).length === 0 ? void 0 : result;
+};
+var mergeRoots = (base, override) => {
+  const result = cloneRoots(base);
+  if (!override) {
+    return result;
+  }
+  for (const [key, value] of Object.entries(override)) {
+    if (value === void 0) {
+      continue;
     }
+    result[key] = cloneArray(value);
   }
-  if (envs.length > 1 && !envs.includes("default")) {
-    throw new import_errors2.AutomationError(
-      `A default environment must be defined first. At one config must not have an environment defined or define a default environment explicitly with 'environement="default"`
+  if (!result.features) {
+    throw new AutomationError(
+      'Environment overrides removed required root "features"'
     );
   }
-  const setters = config.environments;
-  return {
-    env: setters
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Config,
-  EnvironmentReader,
-  defineConfig
+  if (!result.steps) {
+    throw new AutomationError(
+      'Environment overrides removed required root "steps"'
+    );
+  }
+  return result;
+};
+var mergeBuilder = (base, override) => {
+  if (override === void 0) {
+    return base ? cloneBuilder(base) : void 0;
+  }
+  const result = base ? cloneBuilder(base) : {};
+  if (override.format !== void 0) {
+    result.format = override.format;
+  }
+  if (override.target !== void 0) {
+    result.target = Array.isArray(override.target) ? [...override.target] : override.target;
+  }
+  if (override.sourcemap !== void 0) {
+    result.sourcemap = override.sourcemap;
+  }
+  if (override.tsconfig !== void 0) {
+    result.tsconfig = override.tsconfig;
+  }
+  if (override.external !== void 0) {
+    result.external = cloneArray(override.external);
+  }
+  if (override.outDir !== void 0) {
+    result.outDir = override.outDir;
+  }
+  if (override.hooks !== void 0) {
+    const clonedHooks = cloneBuilderHooks(override.hooks);
+    if (clonedHooks) {
+      result.hooks = clonedHooks;
+    } else {
+      delete result.hooks;
+    }
+  }
+  return Object.keys(result).length === 0 ? void 0 : result;
+};
+var cloneConfig = (config) => ({
+  runner: config.runner,
+  roots: cloneRoots(config.roots),
+  modules: config.modules ? cloneModules(config.modules) : void 0,
+  test: config.test ? cloneTest(config.test) : void 0,
+  shim: config.shim ? cloneShim(config.shim) : void 0,
+  events: cloneOptionalArray(config.events),
+  builder: config.builder ? cloneBuilder(config.builder) : void 0,
+  logging: config.logging ? cloneLogging(config.logging) : void 0,
+  reporting: config.reporting ? cloneReporting(config.reporting) : void 0
 });
+var cloneRoots = (roots) => {
+  const cloned = {};
+  for (const [key, value] of Object.entries(roots)) {
+    if (value) {
+      cloned[key] = cloneArray(value);
+    }
+  }
+  return cloned;
+};
+var cloneRootRecord = (roots) => {
+  const cloned = {};
+  for (const [key, value] of Object.entries(roots)) {
+    if (!value) {
+      continue;
+    }
+    cloned[key] = cloneArray(value);
+  }
+  return cloned;
+};
+var cloneGroups = (groups) => {
+  const cloneModuleDeclaration = (value) => {
+    if (typeof value === "string") {
+      return value;
+    }
+    return {
+      name: value.name,
+      submodules: value.submodules ? value.submodules.map((child) => cloneModuleDeclaration(child)) : void 0
+    };
+  };
+  const cloned = {};
+  for (const [key, group] of Object.entries(groups)) {
+    cloned[key] = {
+      root: group.root,
+      modules: group.modules.map((m) => cloneModuleDeclaration(m))
+    };
+  }
+  return cloned;
+};
+var cloneModules = (modules) => {
+  const clone = {};
+  if (modules.relativeRoots) {
+    clone.relativeRoots = cloneRootRecord(modules.relativeRoots);
+  }
+  if (modules.groups) {
+    clone.groups = cloneGroups(modules.groups);
+  }
+  if (modules.explicit) {
+    clone.explicit = cloneArray(modules.explicit);
+  }
+  return clone;
+};
+var cloneTest = (test) => {
+  const clone = {};
+  if (test.timeout !== void 0) {
+    clone.timeout = cloneTimeout(test.timeout);
+  }
+  if (test.tagFilter !== void 0) {
+    clone.tagFilter = test.tagFilter;
+  }
+  if (test.groupLogging !== void 0) {
+    clone.groupLogging = test.groupLogging;
+  }
+  return clone;
+};
+var cloneShim = (shim) => {
+  const clone = {};
+  if (shim.errorCause !== void 0) {
+    clone.errorCause = shim.errorCause;
+  }
+  return clone;
+};
+var cloneLogging = (logging) => {
+  const clone = {};
+  if (logging.http !== void 0) {
+    clone.http = logging.http;
+  }
+  return clone;
+};
+var cloneReporting = (reporting) => {
+  const clone = {};
+  if (reporting.hierarchical) {
+    clone.hierarchical = { ...reporting.hierarchical };
+  }
+  return clone;
+};
+var cloneBuilder = (config) => {
+  const clone = {};
+  if (config.format !== void 0) {
+    clone.format = config.format;
+  }
+  if (config.target !== void 0) {
+    clone.target = Array.isArray(config.target) ? [...config.target] : config.target;
+  }
+  if (config.sourcemap !== void 0) {
+    clone.sourcemap = config.sourcemap;
+  }
+  if (config.tsconfig !== void 0) {
+    clone.tsconfig = config.tsconfig;
+  }
+  if (config.external !== void 0) {
+    clone.external = cloneArray(config.external);
+  }
+  if (config.outDir !== void 0) {
+    clone.outDir = config.outDir;
+  }
+  if (config.hooks) {
+    const clonedHooks = cloneBuilderHooks(config.hooks);
+    if (clonedHooks) {
+      clone.hooks = clonedHooks;
+    }
+  }
+  return clone;
+};
+var cloneBuilderHooks = (hooks) => {
+  const clone = {};
+  if (hooks.before && hooks.before.length > 0) {
+    clone.before = [...hooks.before];
+  }
+  if (hooks.after && hooks.after.length > 0) {
+    clone.after = [...hooks.after];
+  }
+  return Object.keys(clone).length === 0 ? void 0 : clone;
+};
+var cloneTimeout = (timeout) => {
+  if (timeout === void 0) {
+    return void 0;
+  }
+  if (typeof timeout === "number") {
+    return timeout;
+  }
+  if (Array.isArray(timeout)) {
+    const [value, unit] = timeout;
+    return [value, unit];
+  }
+  return { ...timeout };
+};
+var cloneArray = (value) => [...value];
+var cloneOptionalArray = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  return [...value];
+};
+var deepFreeze = (value) => {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const propertyNames = Object.getOwnPropertyNames(value);
+  for (const name of propertyNames) {
+    const property = value[name];
+    if (property && typeof property === "object") {
+      deepFreeze(property);
+    }
+  }
+  return Object.freeze(value);
+};
+
+export { BuilderConfigSchema, Config, EnvironmentSelector, EventsSchema, ExecutorConfigSchema, ModuleFormatSchema, PartialExecutorConfigSchema, PartialRootSchema, PathSchema, ReporterSchema, RootSchema, RunnerSchema, ShimSchema, TagFilterSchema, TestSchema, TimeUnitSchema, TimeoutSchema, defineConfig };
+//# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map