@autometa/config 0.1.27 → 1.0.0-rc.0

package/dist/index.cjs

@@ -0,0 +1,809 @@
+'use strict';
+
+var errors = require('@autometa/errors');
+var path = require('path');
+var zod = require('zod');
+
+// src/config.ts
+
+// 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() {
+    this.detectors = [];
+    this.fallback = "default";
+  }
+  byLiteral(name) {
+    this.detectors.push(() => sanitize(name));
+    return this;
+  }
+  byEnvironmentVariable(variable) {
+    this.detectors.push(() => sanitize(process.env[variable]));
+    return this;
+  }
+  byFactory(factory) {
+    this.detectors.push(() => sanitize(factory()));
+    return this;
+  }
+  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;
+  }
+};
+var TimeUnitSchema = zod.z.enum(["ms", "s", "m", "h"]);
+var TimeoutSchema = zod.z.union([
+  zod.z.number().nonnegative(),
+  zod.z.tuple([zod.z.number().nonnegative(), TimeUnitSchema]),
+  zod.z.object({
+    value: zod.z.number().nonnegative(),
+    unit: TimeUnitSchema.optional()
+  })
+]).optional();
+var RunnerSchema = zod.z.union([zod.z.literal("jest"), zod.z.literal("vitest"), zod.z.literal("playwright")]);
+var TagFilterSchema = zod.z.string().refine(
+  (value) => value.startsWith("@") || value.startsWith("not @"),
+  "tag filter must start with `@` or `not @`"
+).optional();
+var TestSchema = zod.z.object({
+  timeout: TimeoutSchema,
+  tagFilter: TagFilterSchema,
+  groupLogging: zod.z.boolean().optional()
+}).partial();
+var ShimSchema = zod.z.object({
+  errorCause: zod.z.boolean().optional()
+});
+var PathSchema = zod.z.array(zod.z.string());
+var RootSchema = zod.z.object({
+  features: PathSchema,
+  steps: PathSchema,
+  support: PathSchema.optional()
+}).catchall(PathSchema);
+var EventsSchema = zod.z.array(zod.z.string());
+var LoggingSchema = zod.z.object({
+  http: zod.z.boolean().optional()
+}).optional();
+var ReporterSchema = zod.z.object({
+  hierarchical: zod.z.object({
+    bufferOutput: zod.z.boolean().optional()
+  }).optional()
+}).optional();
+var ModuleFormatSchema = zod.z.enum(["cjs", "esm"]);
+var PartialRootSchema = RootSchema.partial();
+var ModuleDeclarationSchema = zod.z.lazy(
+  () => zod.z.union([
+    zod.z.string(),
+    zod.z.object({
+      name: zod.z.string().min(1),
+      submodules: zod.z.array(ModuleDeclarationSchema).optional()
+    })
+  ])
+);
+var ModulesConfigSchema = zod.z.object({
+  stepScoping: zod.z.enum(["global", "scoped"]).optional(),
+  relativeRoots: PartialRootSchema.optional(),
+  groups: zod.z.record(
+    zod.z.object({
+      root: zod.z.string(),
+      modules: zod.z.array(ModuleDeclarationSchema).nonempty()
+    })
+  ).optional(),
+  explicit: zod.z.array(zod.z.string()).optional()
+});
+var SourceMapSchema = zod.z.union([
+  zod.z.literal(true),
+  zod.z.literal(false),
+  zod.z.literal("inline"),
+  zod.z.literal("external")
+]);
+var BuildHookSchema = zod.z.custom((value) => {
+  return typeof value === "function";
+}, {
+  message: "build hooks must be functions"
+});
+var BuilderHooksSchema = zod.z.object({
+  before: zod.z.array(BuildHookSchema).optional(),
+  after: zod.z.array(BuildHookSchema).optional()
+});
+var BuilderConfigSchema = zod.z.object({
+  format: ModuleFormatSchema.optional(),
+  target: zod.z.union([zod.z.string(), zod.z.array(zod.z.string()).nonempty()]).optional(),
+  sourcemap: SourceMapSchema.optional(),
+  tsconfig: zod.z.string().optional(),
+  external: zod.z.array(zod.z.string()).optional(),
+  outDir: zod.z.string().optional(),
+  hooks: BuilderHooksSchema.optional()
+});
+var ExecutorConfigSchema = zod.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 = zod.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.ts
+var Config = class {
+  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 errors.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 errors.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 errors.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 errors.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(path.posix.join(currentPrefix, name2)));
+        continue;
+      }
+      const name = normalizeSlashes(item.name.trim()).replace(/^\/+|\/+$/gu, "");
+      if (!name) {
+        continue;
+      }
+      const nextPrefix = normalizeSlashes(path.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(path.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 errors.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 errors.AutomationError(
+          `Module "${rawFilter}" not found. Available modules: ${scopedOptions.map((o) => o.id).join(", ")}`
+        );
+      }
+      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 errors.AutomationError(
+        `Module "${rawFilter}" not found. Available modules: ${scopedOptions.map((o) => o.id).join(", ")}`
+      );
+    }
+    if (suffixMatches.length > 1) {
+      throw new errors.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 };
+        }
+      }
+    }
+  }
+  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;
+};
+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(path.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;
+      }
+    } else {
+      delete result.hierarchical;
+    }
+  }
+  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 (!result.features) {
+    throw new errors.AutomationError(
+      'Environment overrides removed required root "features"'
+    );
+  }
+  if (!result.steps) {
+    throw new errors.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);
+};
+
+exports.BuilderConfigSchema = BuilderConfigSchema;
+exports.Config = Config;
+exports.EnvironmentSelector = EnvironmentSelector;
+exports.EventsSchema = EventsSchema;
+exports.ExecutorConfigSchema = ExecutorConfigSchema;
+exports.ModuleFormatSchema = ModuleFormatSchema;
+exports.PartialExecutorConfigSchema = PartialExecutorConfigSchema;
+exports.PartialRootSchema = PartialRootSchema;
+exports.PathSchema = PathSchema;
+exports.ReporterSchema = ReporterSchema;
+exports.RootSchema = RootSchema;
+exports.RunnerSchema = RunnerSchema;
+exports.ShimSchema = ShimSchema;
+exports.TagFilterSchema = TagFilterSchema;
+exports.TestSchema = TestSchema;
+exports.TimeUnitSchema = TimeUnitSchema;
+exports.TimeoutSchema = TimeoutSchema;
+exports.defineConfig = defineConfig;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map