@o3co/ts.hocon 1.13.0 → 1.14.0

package/dist/index.js

@@ -1,3659 +1,28 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/coerce.ts
-var DECIMAL_NUMBER_RE = /^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
-function isHoconWs(cp) {
-  if (cp === 9 || cp === 10 || cp === 11 || cp === 12 || cp === 13) return true;
-  if (cp >= 28 && cp <= 31) return true;
-  if (cp === 32 || cp === 160 || cp === 65279) return true;
-  if (cp === 5760) return true;
-  if (cp >= 8192 && cp <= 8202) return true;
-  if (cp === 8232 || cp === 8233 || cp === 8239 || cp === 8287) return true;
-  if (cp === 12288) return true;
-  return false;
-}
-function trimHoconWs(s) {
-  let start = 0;
-  let end = s.length;
-  while (start < end && isHoconWs(s.charCodeAt(start))) {
-    start++;
-  }
-  while (end > start && isHoconWs(s.charCodeAt(end - 1))) {
-    end--;
-  }
-  return s.slice(start, end);
-}
-var TRUTHY = /* @__PURE__ */ new Set(["true", "yes", "on"]);
-var FALSY = /* @__PURE__ */ new Set(["false", "no", "off"]);
-function coerceBoolean(value) {
-  const lower = value.toLowerCase();
-  if (TRUTHY.has(lower)) return true;
-  if (FALSY.has(lower)) return false;
-  return void 0;
-}
-function coerceNumber(value) {
-  if (!DECIMAL_NUMBER_RE.test(value)) return void 0;
-  return Number(value);
-}
-var DURATION_UNITS = {
-  // S19.1–S19.3: the bare nano/micro/milli (+plural) aliases are part of the
-  // spec's unit lists (HOCON.md L1307–L1309) and accepted by Lightbend
-  // (typesafe-config 1.4.6 probe, 2026-08-18); they were missing here.
-  ns: 1e-6,
-  nano: 1e-6,
-  nanos: 1e-6,
-  nanosecond: 1e-6,
-  nanoseconds: 1e-6,
-  us: 1e-3,
-  micro: 1e-3,
-  micros: 1e-3,
-  microsecond: 1e-3,
-  microseconds: 1e-3,
-  ms: 1,
-  milli: 1,
-  millis: 1,
-  millisecond: 1,
-  milliseconds: 1,
-  s: 1e3,
-  second: 1e3,
-  seconds: 1e3,
-  m: 6e4,
-  minute: 6e4,
-  minutes: 6e4,
-  h: 36e5,
-  hour: 36e5,
-  hours: 36e5,
-  d: 864e5,
-  day: 864e5,
-  days: 864e5
-};
-var OUTPUT_DURATION_UNITS = {
-  ns: 1e-6,
-  us: 1e-3,
-  ms: 1,
-  s: 1e3,
-  m: 6e4,
-  h: 36e5,
-  d: 864e5
-};
-function parseDuration(value, outputUnit = "ms") {
-  const trimmed = trimHoconWs(value);
-  let i = 0;
-  while (i < trimmed.length) {
-    const ch = trimmed[i];
-    if (i === 0 && (ch === "-" || ch === "+")) {
-      i++;
-      continue;
-    }
-    if (ch !== "." && (ch < "0" || ch > "9")) break;
-    i++;
-  }
-  if (i === 0) return NaN;
-  const num = Number(trimmed.slice(0, i));
-  if (Number.isNaN(num)) return NaN;
-  const unit = trimHoconWs(trimmed.slice(i));
-  const divisor = OUTPUT_DURATION_UNITS[outputUnit];
-  if (divisor === void 0) return NaN;
-  if (unit === "") {
-    return num / divisor;
-  }
-  const mult = DURATION_UNITS[unit];
-  if (mult === void 0) return NaN;
-  const ms = num * mult;
-  return ms / divisor;
-}
-var BYTE_UNITS = {
-  // S21.1–S21.4 — the EXACT Lightbend/typesafe-config unit set (1.4.6 probe,
-  // 2026-08-18). Multi-letter units are case-sensitive: the SI decimal short
-  // form is `kB` (NOT `KB`/`kb` — Lightbend rejects both), higher decimals
-  // are `MB`…`YB`, binary prefixes are `Ki`/`KiB`…`Yi`/`YiB` with capital
-  // first letter, and long forms are lowercase only (`kilobyte`, never
-  // `Kilobyte`). Only the bare byte unit (`B`/`b`) and the single-letter
-  // -Xmx forms accept both cases. The old case-insensitive fallback and the
-  // lowercase alias rows accepted spellings Lightbend rejects — removed.
-  B: 1,
-  b: 1,
-  byte: 1,
-  bytes: 1,
-  kB: 1e3,
-  kilobyte: 1e3,
-  kilobytes: 1e3,
-  MB: 1e6,
-  megabyte: 1e6,
-  megabytes: 1e6,
-  GB: 1e9,
-  gigabyte: 1e9,
-  gigabytes: 1e9,
-  TB: 1e12,
-  terabyte: 1e12,
-  terabytes: 1e12,
-  PB: 1e15,
-  petabyte: 1e15,
-  petabytes: 1e15,
-  EB: 1e18,
-  exabyte: 1e18,
-  exabytes: 1e18,
-  ZB: 1e21,
-  zettabyte: 1e21,
-  zettabytes: 1e21,
-  YB: 1e24,
-  yottabyte: 1e24,
-  yottabytes: 1e24,
-  Ki: 1024,
-  KiB: 1024,
-  kibibyte: 1024,
-  kibibytes: 1024,
-  Mi: 1048576,
-  MiB: 1048576,
-  mebibyte: 1048576,
-  mebibytes: 1048576,
-  Gi: 1073741824,
-  GiB: 1073741824,
-  gibibyte: 1073741824,
-  gibibytes: 1073741824,
-  Ti: 1099511627776,
-  TiB: 1099511627776,
-  tebibyte: 1099511627776,
-  tebibytes: 1099511627776,
-  Pi: 1024 ** 5,
-  PiB: 1024 ** 5,
-  pebibyte: 1024 ** 5,
-  pebibytes: 1024 ** 5,
-  Ei: 1024 ** 6,
-  EiB: 1024 ** 6,
-  exbibyte: 1024 ** 6,
-  exbibytes: 1024 ** 6,
-  Zi: 1024 ** 7,
-  ZiB: 1024 ** 7,
-  zebibyte: 1024 ** 7,
-  zebibytes: 1024 ** 7,
-  Yi: 1024 ** 8,
-  YiB: 1024 ** 8,
-  yobibyte: 1024 ** 8,
-  yobibytes: 1024 ** 8,
-  // S21.4 — single-letter abbreviations → powers of two (java -Xmx
-  // convention); Lightbend accepts BOTH cases here, through the full ladder.
-  K: 1024,
-  k: 1024,
-  M: 1024 ** 2,
-  m: 1024 ** 2,
-  G: 1024 ** 3,
-  g: 1024 ** 3,
-  T: 1024 ** 4,
-  t: 1024 ** 4,
-  P: 1024 ** 5,
-  p: 1024 ** 5,
-  E: 1024 ** 6,
-  e: 1024 ** 6,
-  Z: 1024 ** 7,
-  z: 1024 ** 7,
-  Y: 1024 ** 8,
-  y: 1024 ** 8
-};
-var OUTPUT_BYTE_UNITS = {
-  B: 1,
-  KB: 1e3,
-  KiB: 1024,
-  MB: 1e6,
-  MiB: 1048576,
-  GB: 1e9,
-  GiB: 1073741824,
-  TB: 1e12,
-  TiB: 1099511627776
-};
-function parseBytes(value, outputUnit = "B") {
-  const trimmed = trimHoconWs(value);
-  let i = 0;
-  while (i < trimmed.length) {
-    const ch = trimmed[i];
-    if (i === 0 && (ch === "-" || ch === "+")) {
-      i++;
-      continue;
-    }
-    if (ch !== "." && (ch < "0" || ch > "9")) break;
-    i++;
-  }
-  if (i === 0) return NaN;
-  const num = Number(trimmed.slice(0, i));
-  if (Number.isNaN(num)) return NaN;
-  const unit = trimHoconWs(trimmed.slice(i));
-  const divisor = OUTPUT_BYTE_UNITS[outputUnit];
-  if (divisor === void 0) return NaN;
-  if (unit === "") {
-    const bytes2 = Math.trunc(num);
-    if (Math.abs(bytes2) > Number.MAX_SAFE_INTEGER) {
-      throw new RangeError("byte size overflows representable range (max 2^53-1 bytes)");
-    }
-    return bytes2 / divisor;
-  }
-  const mult = BYTE_UNITS[unit];
-  if (mult === void 0) return NaN;
-  const bytes = num * mult;
-  if (Math.abs(bytes) > Number.MAX_SAFE_INTEGER) {
-    throw new RangeError("byte size overflows representable range (max 2^53-1 bytes)");
-  }
-  const result = bytes / divisor;
-  return outputUnit === "B" ? Math.round(result) : result;
-}
-
-// src/errors.ts
-var ParseError = class extends Error {
-  constructor(message, line, col, file) {
-    super(message);
-    this.line = line;
-    this.col = col;
-    this.file = file;
-    this.name = "ParseError";
-  }
-};
-var ResolveError = class extends Error {
-  constructor(message, path2, line, col, file) {
-    super(message);
-    this.path = path2;
-    this.line = line;
-    this.col = col;
-    this.file = file;
-    this.name = "ResolveError";
-  }
-};
-var PackageLookupError = class extends ResolveError {
-  constructor(message, identifier, packageFile, line, col) {
-    super(message, `${identifier}/${packageFile}`, line, col);
-    this.identifier = identifier;
-    this.packageFile = packageFile;
-    this.name = "PackageLookupError";
-  }
-};
-var ConfigError = class extends Error {
-  constructor(message, path2) {
-    super(message);
-    this.path = path2;
-    this.name = "ConfigError";
-  }
-};
-var NotResolvedError = class extends ConfigError {
-  constructor(path2) {
-    super(`value at path "${path2}" is not resolved (call resolve() first)`, path2);
-    this.name = "NotResolvedError";
-  }
-};
-
-// src/internal/resolver/fold-self-ref.ts
-function substFullKey(s) {
-  return stringSegmentsToKey(s.segments.map((seg) => seg.text));
-}
-function stringSegmentsToKey(segments) {
-  return segments.map((t) => {
-    if (t === "" || /[^a-zA-Z0-9\-_]/.test(t)) {
-      return `"${t.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-    }
-    return t;
-  }).join(".");
-}
-function prefixSelfRefRemainder(s, fullKey) {
-  const texts = s.segments.map((seg) => seg.text);
-  if (!stringSegmentsToKey(texts).startsWith(fullKey + ".")) return null;
-  for (let n = 1; n < texts.length; n++) {
-    if (stringSegmentsToKey(texts.slice(0, n)) === fullKey) return texts.slice(n);
-  }
-  return null;
-}
-function navigateResolverValue(v, remainder) {
-  let cur = v;
-  for (const seg of remainder) {
-    if (isSubst(cur) || isConcat(cur)) return null;
-    if (isResObj(cur)) {
-      const next = cur.fields.get(seg);
-      if (next === void 0) return void 0;
-      cur = next;
-      continue;
-    }
-    const hv = cur;
-    if (hv.kind === "object") {
-      const next = hv.fields.get(seg);
-      if (next === void 0) return void 0;
-      cur = next;
-      continue;
-    }
-    return void 0;
-  }
-  return cur;
-}
-function foldPrefixSelfRef(s, replacement, remainder) {
-  const navigated = navigateResolverValue(replacement, remainder);
-  if (navigated === null) return s;
-  if (navigated === void 0) {
-    return {
-      _kind: "subst-placeholder",
-      segments: s.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
-      optional: s.optional,
-      knownAbsent: true,
-      listSuffix: s.listSuffix,
-      line: s.line,
-      col: s.col,
-      prefixLen: s.prefixLen
-    };
-  }
-  return cloneResolverValue(navigated);
-}
-function mergeResObjLayers(base, top) {
-  const fields = new Map(base.fields);
-  for (const [k, tv] of top.fields) {
-    const bv = fields.get(k);
-    if (bv !== void 0 && isResObj(bv) && isResObj(tv)) {
-      fields.set(k, mergeResObjLayers(bv, tv));
-    } else {
-      fields.set(k, tv);
-    }
-  }
-  const priorValues = new Map(base.priorValues);
-  for (const [k, pv] of top.priorValues) priorValues.set(k, pv);
-  const resetKeys = new Set(base.resetKeys);
-  for (const k of top.resetKeys) resetKeys.add(k);
-  return {
-    _kind: "res-obj",
-    fields,
-    priorValues,
-    resetKeys
-  };
-}
-function containsSelfRef(v, fullKey) {
-  return containsSelfRefInner(v, fullKey, true);
-}
-function containsSelfRefInner(v, fullKey, allowPrefix) {
-  if (isSubst(v))
-    return !v.knownAbsent && (substFullKey(v) === fullKey || allowPrefix && prefixSelfRefRemainder(v, fullKey) !== null);
-  if (isConcat(v)) return v.nodes.some((n) => containsSelfRefInner(n, fullKey, allowPrefix));
-  if (isResObj(v)) {
-    for (const f of v.fields.values()) {
-      if (containsSelfRefInner(f, fullKey, false)) return true;
-    }
-    return false;
-  }
-  const hv = v;
-  if (hv.kind === "array") {
-    return hv.items.some((item) => containsSelfRefInner(item, fullKey, allowPrefix));
-  }
-  if (hv.kind === "object") {
-    for (const f of hv.fields.values()) {
-      if (containsSelfRefInner(f, fullKey, false)) return true;
-    }
-    return false;
-  }
-  return false;
-}
-function foldSelfRef(v, fullKey, replacement) {
-  return foldSelfRefInner(v, fullKey, replacement, true);
-}
-function foldSelfRefInner(v, fullKey, replacement, allowPrefix) {
-  if (isSubst(v)) {
-    if (substFullKey(v) === fullKey) return replacement;
-    if (allowPrefix) {
-      const remainder = prefixSelfRefRemainder(v, fullKey);
-      if (remainder !== null) return foldPrefixSelfRef(v, replacement, remainder);
-    }
-    return v;
-  }
-  if (isConcat(v)) {
-    return {
-      _kind: "concat-placeholder",
-      nodes: v.nodes.map((n) => foldSelfRefInner(n, fullKey, replacement, allowPrefix)),
-      line: v.line,
-      col: v.col
-    };
-  }
-  if (isResObj(v)) {
-    const newFields = /* @__PURE__ */ new Map();
-    for (const [k, val] of v.fields) {
-      newFields.set(k, foldSelfRefInner(val, fullKey, replacement, false));
-    }
-    return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues), resetKeys: new Set(v.resetKeys) };
-  }
-  const hv = v;
-  if (hv.kind === "array") {
-    return {
-      kind: "array",
-      items: hv.items.map(
-        (item) => foldSelfRefInner(item, fullKey, replacement, allowPrefix)
-      )
-    };
-  }
-  if (hv.kind === "object") {
-    const newFields = /* @__PURE__ */ new Map();
-    for (const [k, val] of hv.fields) {
-      newFields.set(k, foldSelfRefInner(val, fullKey, replacement, false));
-    }
-    return { kind: "object", fields: newFields };
-  }
-  return v;
-}
-function foldKnownAbsentSelfRef(v, fullKey, replacement) {
-  if (isSubst(v)) {
-    return v.knownAbsent && substFullKey(v) === fullKey ? replacement : v;
-  }
-  if (isConcat(v)) {
-    return {
-      _kind: "concat-placeholder",
-      nodes: v.nodes.map((n) => foldKnownAbsentSelfRef(n, fullKey, replacement)),
-      line: v.line,
-      col: v.col
-    };
-  }
-  if (isResObj(v)) {
-    const newFields = /* @__PURE__ */ new Map();
-    for (const [k, val] of v.fields) {
-      newFields.set(k, foldKnownAbsentSelfRef(val, fullKey, replacement));
-    }
-    return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues), resetKeys: new Set(v.resetKeys) };
-  }
-  const hv = v;
-  if (hv.kind === "array") {
-    return {
-      kind: "array",
-      items: hv.items.map((item) => foldKnownAbsentSelfRef(item, fullKey, replacement))
-    };
-  }
-  if (hv.kind === "object") {
-    const newFields = /* @__PURE__ */ new Map();
-    for (const [k, val] of hv.fields) {
-      newFields.set(k, foldKnownAbsentSelfRef(val, fullKey, replacement));
-    }
-    return { kind: "object", fields: newFields };
-  }
-  return v;
-}
-function foldOrSkipPrior(prior, fullKey, old) {
-  if (!containsSelfRef(prior, fullKey)) return cloneResolverValue(prior);
-  if (old === void 0) return foldOptionalSelfRefAbsent(prior, fullKey);
-  if (isSubst(prior)) {
-    const remainder = prefixSelfRefRemainder(prior, fullKey);
-    if (remainder !== null) {
-      const navigated = navigateResolverValue(old, remainder);
-      if (navigated === void 0 && prior.optional) return cloneResolverValue(old);
-      if (navigated !== null && navigated !== void 0 && isResObj(navigated) && isResObj(old)) {
-        return mergeResObjLayers(
-          cloneResolverValue(old),
-          cloneResolverValue(navigated)
-        );
-      }
-    }
-  }
-  return foldSelfRef(prior, fullKey, old);
-}
-function foldOptionalSelfRefAbsent(v, fullKey) {
-  return foldOptionalSelfRefAbsentInner(v, fullKey, true);
-}
-function foldOptionalSelfRefAbsentInner(v, fullKey, allowPrefix) {
-  if (isSubst(v) && (substFullKey(v) === fullKey || allowPrefix && prefixSelfRefRemainder(v, fullKey) !== null)) {
-    if (!v.optional) return void 0;
-    return {
-      _kind: "subst-placeholder",
-      segments: v.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
-      optional: v.optional,
-      knownAbsent: true,
-      listSuffix: v.listSuffix,
-      line: v.line,
-      col: v.col,
-      prefixLen: v.prefixLen
-    };
-  }
-  if (isConcat(v)) {
-    const nodes = [];
-    for (const node of v.nodes) {
-      const folded = foldOptionalSelfRefAbsentInner(node, fullKey, allowPrefix);
-      if (folded === void 0) return void 0;
-      nodes.push(folded);
-    }
-    return { _kind: "concat-placeholder", nodes, line: v.line, col: v.col };
-  }
-  if (isResObj(v)) {
-    const fields = /* @__PURE__ */ new Map();
-    for (const [key, value] of v.fields) {
-      const folded = foldOptionalSelfRefAbsentInner(value, fullKey, false);
-      if (folded === void 0) return void 0;
-      fields.set(key, folded);
-    }
-    return { _kind: "res-obj", fields, priorValues: new Map(v.priorValues), resetKeys: new Set(v.resetKeys) };
-  }
-  const hv = v;
-  if (hv.kind === "array") {
-    const items = [];
-    for (const item of hv.items) {
-      const folded = foldOptionalSelfRefAbsentInner(item, fullKey, allowPrefix);
-      if (folded === void 0) return void 0;
-      items.push(folded);
-    }
-    return { kind: "array", items };
-  }
-  if (hv.kind === "object") {
-    const fields = /* @__PURE__ */ new Map();
-    for (const [key, value] of hv.fields) {
-      const folded = foldOptionalSelfRefAbsentInner(value, fullKey, false);
-      if (folded === void 0) return void 0;
-      fields.set(key, folded);
-    }
-    return { kind: "object", fields };
-  }
-  return cloneResolverValue(v);
-}
-function cloneResolverValue(v) {
-  if (isSubst(v)) {
-    return {
-      _kind: "subst-placeholder",
-      segments: v.segments.map((seg) => ({ text: seg.text, line: seg.line, col: seg.col })),
-      optional: v.optional,
-      knownAbsent: v.knownAbsent,
-      listSuffix: v.listSuffix,
-      line: v.line,
-      col: v.col,
-      prefixLen: v.prefixLen
-    };
-  }
-  if (isConcat(v)) {
-    return {
-      _kind: "concat-placeholder",
-      nodes: v.nodes.map((n) => cloneResolverValue(n)),
-      line: v.line,
-      col: v.col
-    };
-  }
-  if (isResObj(v)) {
-    const newFields = /* @__PURE__ */ new Map();
-    for (const [k, val] of v.fields) newFields.set(k, cloneResolverValue(val));
-    const newPriors = /* @__PURE__ */ new Map();
-    for (const [k, val] of v.priorValues) newPriors.set(k, cloneResolverValue(val));
-    return { _kind: "res-obj", fields: newFields, priorValues: newPriors, resetKeys: new Set(v.resetKeys) };
-  }
-  const hv = v;
-  if (hv.kind === "array") {
-    return {
-      kind: "array",
-      items: hv.items.map((item) => cloneResolverValue(item))
-    };
-  }
-  if (hv.kind === "object") {
-    const newFields = /* @__PURE__ */ new Map();
-    for (const [k, val] of hv.fields) {
-      newFields.set(k, cloneResolverValue(val));
-    }
-    return { kind: "object", fields: newFields };
-  }
-  return hv;
-}
-function foldNestedSelfRefs(v, pathPrefix) {
-  if (!isResObj(v)) return v;
-  const newFields = /* @__PURE__ */ new Map();
-  for (const [k, fieldVal] of v.fields) {
-    const childPath = [...pathPrefix, k];
-    const fullKey = stringSegmentsToKey(childPath);
-    const folded = foldNestedSelfRefs(fieldVal, childPath);
-    let finalVal = folded;
-    if (containsSelfRef(folded, fullKey)) {
-      const leafPrior = v.priorValues.get(k);
-      if (leafPrior !== void 0) {
-        const leafPriorFolded = foldNestedSelfRefs(leafPrior, childPath);
-        finalVal = foldSelfRef(folded, fullKey, leafPriorFolded);
-      }
-    }
-    newFields.set(k, finalVal);
-  }
-  return { _kind: "res-obj", fields: newFields, priorValues: new Map(v.priorValues), resetKeys: new Set(v.resetKeys) };
-}
-function containsSubstByPath(v, target) {
-  if (isSubst(v)) return !v.knownAbsent && segmentsTextEqual(v.segments, target);
-  if (isConcat(v)) return v.nodes.some((n) => containsSubstByPath(n, target));
-  if (isResObj(v)) {
-    for (const f of v.fields.values()) {
-      if (containsSubstByPath(f, target)) return true;
-    }
-    return false;
-  }
-  const hv = v;
-  if (hv.kind === "array") {
-    return hv.items.some((item) => containsSubstByPath(item, target));
-  }
-  if (hv.kind === "object") {
-    for (const f of hv.fields.values()) {
-      if (containsSubstByPath(f, target)) return true;
-    }
-    return false;
-  }
-  return false;
-}
-function segmentsTextEqual(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const ai = a[i];
-    const bi = b[i];
-    if (ai === void 0 || bi === void 0 || ai.text !== bi.text) return false;
-  }
-  return true;
-}
-
-// src/internal/resolver/types.ts
-var separatorValues = /* @__PURE__ */ new WeakSet();
-function isSubst(v) {
-  return v._kind === "subst-placeholder";
-}
-function isConcat(v) {
-  return v._kind === "concat-placeholder";
-}
-function isResObj(v) {
-  return v._kind === "res-obj";
-}
-function makeResObj() {
-  return { _kind: "res-obj", fields: /* @__PURE__ */ new Map(), priorValues: /* @__PURE__ */ new Map(), resetKeys: /* @__PURE__ */ new Set() };
-}
-function mergeUnresolved(receiver, fallback) {
-  const result = makeResObj();
-  for (const [k, v] of fallback.fields) {
-    result.fields.set(k, v);
-  }
-  for (const [k, v] of fallback.priorValues) {
-    result.priorValues.set(k, v);
-  }
-  for (const [k, rv] of receiver.fields) {
-    const existing = result.fields.get(k);
-    if (existing !== void 0) {
-      const recPrior = receiver.priorValues.get(k);
-      if (recPrior !== void 0 && !isResObj(recPrior)) {
-        result.fields.set(k, rv);
-        continue;
-      }
-      if (isResObj(rv) && isResObj(existing)) {
-        result.fields.set(k, mergeUnresolved(rv, existing));
-        continue;
-      }
-      const foldedPrior = foldOrSkipPrior(existing, k, void 0);
-      if (foldedPrior !== void 0) result.priorValues.set(k, foldedPrior);
-    }
-    result.fields.set(k, rv);
-  }
-  for (const [k, v] of receiver.priorValues) {
-    if (receiver.fields.has(k)) {
-      result.priorValues.set(k, v);
-    }
-  }
-  return result;
-}
-
-// src/internal/resolver/utils.ts
-function segmentsToKey(segments) {
-  return segments.map((s) => {
-    const t = s.text;
-    if (t === "" || /[^a-zA-Z0-9\-_]/.test(t)) {
-      return `"${t.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-    }
-    return t;
-  }).join(".");
-}
-function lookupPath(root, segments) {
-  const [head, ...tail] = segments;
-  if (head === void 0) return void 0;
-  const key = head.text;
-  const val = root.fields.get(key);
-  if (val === void 0) return void 0;
-  if (tail.length === 0) return val;
-  if (isResObj(val)) return lookupPath(val, tail);
-  return void 0;
-}
-function lookupResObj(root, segments) {
-  let cur = root;
-  for (const seg of segments) {
-    const val = cur.fields.get(seg.text);
-    if (val === void 0 || !isResObj(val)) return void 0;
-    cur = val;
-  }
-  return cur;
-}
-function deepMergeHoconValues(base, overlay) {
-  const merged = new Map(base.fields);
-  for (const [k, v] of overlay.fields) {
-    const existing = merged.get(k);
-    if (existing?.kind === "object" && v.kind === "object") {
-      merged.set(k, deepMergeHoconValues(existing, v));
-    } else {
-      merged.set(k, v);
-    }
-  }
-  return { kind: "object", fields: merged };
-}
-function deepMergeResObjInto(dst, src, pathPrefix = []) {
-  for (const [k, srcVal] of src.fields) {
-    const childPrefix = [...pathPrefix, k];
-    const fullKey = stringSegmentsToKey(childPrefix);
-    const dstVal = dst.fields.get(k);
-    if (dstVal !== void 0 && isResObj(dstVal) && isResObj(srcVal)) {
-      const priorExisting = dst.priorValues.get(k);
-      const prior = foldOrSkipPrior(dstVal, fullKey, priorExisting);
-      if (prior !== void 0) dst.priorValues.set(k, prior);
-      deepMergeResObjInto(dstVal, srcVal, childPrefix);
-    } else {
-      if (dstVal !== void 0) {
-        if (src.resetKeys.has(k)) {
-          dst.priorValues.delete(k);
-        } else {
-          const dstFolded = foldOrSkipPrior(dstVal, fullKey, dst.priorValues.get(k));
-          if (dstFolded !== void 0) {
-            const srcPrior = src.priorValues.get(k);
-            if (srcPrior !== void 0) {
-              dst.priorValues.set(k, foldKnownAbsentSelfRef(srcPrior, fullKey, dstFolded));
-            } else {
-              dst.priorValues.set(k, dstFolded);
-            }
-          }
-        }
-      }
-      dst.fields.set(k, srcVal);
-    }
-  }
-  for (const [k, srcPrior] of src.priorValues) {
-    if (!dst.priorValues.has(k)) {
-      dst.priorValues.set(k, srcPrior);
-    }
-  }
-  for (const k of src.resetKeys) dst.resetKeys.add(k);
-}
-function hoconValueToResObj(hv) {
-  const obj = makeResObj();
-  if (hv.kind !== "object") return obj;
-  for (const [key, val] of hv.fields) {
-    if (val.kind === "object") {
-      obj.fields.set(key, hoconValueToResObj(val));
-    } else {
-      obj.fields.set(key, val);
-    }
-  }
-  return obj;
-}
-function isFileNotFoundError(e) {
-  if (!(e instanceof Error)) return false;
-  const code = e.code;
-  if (code === "ENOENT" || code === "MODULE_NOT_FOUND") return true;
-  const msg = e.message.toLowerCase();
-  return msg.includes("not found") || msg.includes("no such file") || msg.includes("enoent");
-}
-
-// src/internal/resolver/include-loader.ts
-import { createRequire } from "module";
-import * as nodePath from "path";
-import { pathToFileURL } from "url";
-
-// src/internal/lexer/lexer.ts
-function isHoconWhitespace(ch) {
-  const cp = ch.codePointAt(0) ?? -1;
-  if (cp === 9 || cp === 10 || cp === 11 || cp === 12 || cp === 13) return true;
-  if (cp >= 28 && cp <= 31) return true;
-  if (cp === 32 || cp === 160 || cp === 65279) return true;
-  if (cp === 5760) return true;
-  if (cp >= 8192 && cp <= 8202) return true;
-  if (cp === 8232 || cp === 8233 || cp === 8239 || cp === 8287) return true;
-  if (cp === 12288) return true;
-  return false;
-}
-function isHoconNewline(ch) {
-  return ch === "\n";
-}
-var SINGLE_CHAR_TOKENS = {
-  "{": "lbrace",
-  "}": "rbrace",
-  "[": "lbracket",
-  "]": "rbracket",
-  ",": "comma",
-  ":": "colon"
-};
-var Lexer = class {
-  constructor(input) {
-    this.input = input;
-    this.pos = 0;
-    this.line = 1;
-    this.col = 1;
-    this.hadSpace = false;
-    // Accumulates literal whitespace chars consumed between tokens. Reset on every
-    // token push. Used so the parser can preserve path-expression whitespace
-    // (xx.hocon#42, E13) — e.g. tab vs space adjacent to dots in key paths.
-    // Comment text is NOT accumulated; only the actual WS chars.
-    this.whitespaceBuffer = "";
-    this.tokens = [];
-    if (input.charCodeAt(0) === 65279) this.input = input.slice(1);
-  }
-  tokenize() {
-    while (this.pos < this.input.length) {
-      const sl = this.line, sc = this.col;
-      const ch = this.peek();
-      if (isHoconNewline(ch)) {
-        this.advance();
-        if (this.tokens[this.tokens.length - 1]?.kind !== "newline") {
-          this.push("newline", "\n", sl, sc);
-        }
-        continue;
-      }
-      if (isHoconWhitespace(ch)) {
-        this.whitespaceBuffer += ch;
-        this.advance();
-        this.hadSpace = true;
-        continue;
-      }
-      if (ch === "/" && this.peek(1) === "/") {
-        while (this.pos < this.input.length && this.peek() !== "\n") this.advance();
-        this.hadSpace = true;
-        continue;
-      }
-      if (ch === "#") {
-        while (this.pos < this.input.length && this.peek() !== "\n") this.advance();
-        this.hadSpace = true;
-        continue;
-      }
-      if (ch in SINGLE_CHAR_TOKENS) {
-        this.advance();
-        this.push(SINGLE_CHAR_TOKENS[ch], ch, sl, sc);
-        continue;
-      }
-      if (ch === "=") {
-        this.advance();
-        this.push("equals", "=", sl, sc);
-        continue;
-      }
-      if (ch === "+" && this.peek(1) === "=") {
-        this.advance();
-        this.advance();
-        this.push("plus_equals", "+=", sl, sc);
-        continue;
-      }
-      if (ch === "$" && this.peek(1) === "{") {
-        this.advance();
-        this.advance();
-        const payload = this.parseSubstBody(sl, sc);
-        const value = payload.segments.map((s) => {
-          const t = s.text;
-          if (t === "" || t.includes(".") || t.includes(" ") || t.includes("	") || t.includes('"') || t.includes("\\") || t !== t.trim()) {
-            const escaped = t.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-            return `"${escaped}"`;
-          }
-          return t;
-        }).join(".");
-        this.pushSubst(payload, value, sl, sc);
-        continue;
-      }
-      if (ch === '"' && this.peek(1) === '"' && this.peek(2) === '"') {
-        this.advance();
-        this.advance();
-        this.advance();
-        let value = "";
-        let closed = false;
-        while (this.pos < this.input.length) {
-          if (this.peek() === '"') {
-            let quoteCount = 0;
-            while (this.pos < this.input.length && this.peek() === '"') {
-              quoteCount++;
-              this.advance();
-            }
-            if (quoteCount >= 3) {
-              for (let i = 0; i < quoteCount - 3; i++) value += '"';
-              closed = true;
-              break;
-            }
-            for (let i = 0; i < quoteCount; i++) value += '"';
-            continue;
-          }
-          value += this.advance();
-        }
-        if (!closed) {
-          throw new ParseError("unterminated triple-quoted string", sl, sc);
-        }
-        this.push("triple_string", value, sl, sc, true);
-        continue;
-      }
-      if (ch === '"') {
-        this.advance();
-        const value = this.readQuotedStringBody(sl, sc);
-        this.push("string", value, sl, sc, true);
-        continue;
-      }
-      if (isUnquotedStart(ch)) {
-        let value = "";
-        while (this.pos < this.input.length && isUnquotedContinue(this.peek(), () => this.peek(1))) {
-          value += this.advance();
-        }
-        this.push("unquoted", value.trimEnd(), sl, sc);
-        continue;
-      }
-      throw new ParseError(`unexpected character: ${JSON.stringify(ch)}`, sl, sc);
-    }
-    this.tokens.push({ kind: "eof", value: "", line: this.line, col: this.col, isQuoted: false, precedingSpace: false, precedingWhitespace: "" });
-    return this.tokens;
-  }
-  peek(offset = 0) {
-    return this.input[this.pos + offset] ?? "";
-  }
-  advance() {
-    const ch = this.input[this.pos++] ?? "";
-    if (ch === "\n") {
-      this.line++;
-      this.col = 1;
-    } else {
-      this.col++;
-    }
-    return ch;
-  }
-  push(kind, value, l, c, isQuoted = false) {
-    this.tokens.push({ kind, value, line: l, col: c, isQuoted, precedingSpace: this.hadSpace, precedingWhitespace: this.whitespaceBuffer });
-    this.hadSpace = false;
-    this.whitespaceBuffer = "";
-  }
-  pushSubst(payload, value, l, c) {
-    this.tokens.push({ kind: "subst", value, line: l, col: c, isQuoted: false, precedingSpace: this.hadSpace, precedingWhitespace: this.whitespaceBuffer, subst: payload });
-    this.hadSpace = false;
-    this.whitespaceBuffer = "";
-  }
-  /**
-   * Read body of a quoted string. Opening `"` must already be consumed.
-   * Returns decoded string. Throws ParseError on unterminated/invalid-escape.
-   * openLine/openCol are the position of the opening `"` for error reporting.
-   */
-  readQuotedStringBody(openLine, openCol) {
-    let value = "";
-    while (this.pos < this.input.length && this.peek() !== '"') {
-      if (this.peek() === "\n") throw new ParseError("unterminated string", openLine, openCol);
-      if (this.peek() === "\\") {
-        const escCol = this.col;
-        this.advance();
-        if (this.pos >= this.input.length) {
-          throw new ParseError("unterminated string", openLine, openCol);
-        }
-        const esc = this.advance();
-        switch (esc) {
-          case "n":
-            value += "\n";
-            break;
-          case "t":
-            value += "	";
-            break;
-          case "r":
-            value += "\r";
-            break;
-          case '"':
-            value += '"';
-            break;
-          case "\\":
-            value += "\\";
-            break;
-          case "/":
-            value += "/";
-            break;
-          case "b":
-            value += "\b";
-            break;
-          case "f":
-            value += "\f";
-            break;
-          case "u": {
-            if (this.pos + 4 > this.input.length) {
-              throw new ParseError("invalid unicode escape", openLine, escCol);
-            }
-            const hex = this.input.slice(this.pos, this.pos + 4);
-            if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
-              throw new ParseError("invalid unicode escape", openLine, escCol);
-            }
-            const code = parseInt(hex, 16);
-            value += String.fromCharCode(code);
-            for (let i = 0; i < 4; i++) this.advance();
-            break;
-          }
-          default:
-            throw new ParseError(`unknown escape sequence: \\${esc}`, openLine, escCol);
-        }
-      } else {
-        value += this.advance();
-      }
-    }
-    if (this.pos >= this.input.length || this.peek() !== '"') {
-      throw new ParseError("unterminated string", openLine, openCol);
-    }
-    this.advance();
-    return value;
-  }
-  /**
-   * Parse the body of a `${...}` substitution (called after `${` has been consumed).
-   * Implements Appendix A state machine from the cross-language spec.
-   *
-   * S13c extension: if the segment-collection loop encounters `[`, it delegates to
-   * `parseListSuffix()` which consumes the literal `[]` and sets `listSuffix=true`.
-   * ASCII space/tab before `[` is buffered in `pendingWs` and discarded (E7).
-   */
-  parseSubstBody(startLine, startCol) {
-    let optional = false;
-    if (this.peek() === "?") {
-      this.advance();
-      optional = true;
-    }
-    let curText = "";
-    let curStarted = false;
-    let curLine = 0;
-    let curCol = 0;
-    let pendingWs = "";
-    const segments = [];
-    let lastDot = null;
-    let listSuffix = false;
-    while (true) {
-      if (this.pos >= this.input.length) {
-        throw new ParseError("unterminated substitution", startLine, startCol);
-      }
-      const ch = this.peek();
-      if (ch === "}") {
-        this.advance();
-        pendingWs = "";
-        break;
-      } else if (ch === "[") {
-        if (!curStarted) {
-          throw new ParseError("empty segment before '[]' suffix in substitution path", startLine, this.col);
-        }
-        for (const w of pendingWs) {
-          if (w !== " " && w !== "	") {
-            throw new ParseError(
-              `only ASCII space or tab allowed between substitution path and '[]' suffix (got ${JSON.stringify(w)}, HOCON extra-spec E7)`,
-              startLine,
-              this.col
-            );
-          }
-        }
-        segments.push({ text: curText, line: curLine, col: curCol });
-        pendingWs = "";
-        listSuffix = this.parseListSuffix(startLine);
-        break;
-      } else if (ch === '"') {
-        const qLine = startLine;
-        const qCol = this.col;
-        if (curStarted) {
-          curText += pendingWs;
-        }
-        pendingWs = "";
-        this.advance();
-        const decoded = this.readQuotedStringBody(qLine, qCol);
-        curText += decoded;
-        if (!curStarted) {
-          curLine = qLine;
-          curCol = qCol;
-          curStarted = true;
-        }
-      } else if (isUnquotedSubstChar(ch)) {
-        if (ch === "-" && !curStarted && !isDecimalDigit(this.peek(1))) {
-          const after = this.peek(1) === "" ? "EOF" : JSON.stringify(this.peek(1));
-          throw new ParseError(
-            `unquoted path segment cannot begin with '-' unless followed by a digit (got '-' then ${after}, HOCON.md L270-276)`,
-            startLine,
-            this.col
-          );
-        }
-        const uCol = this.col;
-        if (curStarted) {
-          curText += pendingWs;
-        }
-        pendingWs = "";
-        if (!curStarted) {
-          curLine = startLine;
-          curCol = uCol;
-          curStarted = true;
-        }
-        while (this.pos < this.input.length && isUnquotedSubstChar(this.peek())) {
-          curText += this.advance();
-        }
-      } else if (ch === ".") {
-        const dotCol = this.col;
-        pendingWs = "";
-        if (!curStarted) {
-          throw new ParseError("empty segment in path", startLine, dotCol);
-        }
-        segments.push({ text: curText, line: curLine, col: curCol });
-        curText = "";
-        curStarted = false;
-        curLine = 0;
-        curCol = 0;
-        lastDot = [startLine, dotCol];
-        this.advance();
-      } else if (isHoconNewline(ch)) {
-        throw new ParseError("unterminated substitution", startLine, startCol);
-      } else if (isHoconWhitespace(ch)) {
-        pendingWs += ch;
-        this.advance();
-      } else {
-        throw new ParseError(`unexpected character in substitution path: ${JSON.stringify(ch)}`, startLine, this.col);
-      }
-    }
-    if (!listSuffix) {
-      if (curStarted) {
-        segments.push({ text: curText, line: curLine, col: curCol });
-      } else if (segments.length === 0) {
-        throw new ParseError("empty substitution path", startLine, startCol);
-      } else {
-        const [errLine, errCol] = lastDot ?? [startLine, startCol];
-        throw new ParseError("empty segment in path", errLine, errCol);
-      }
-    }
-    return { segments, optional, listSuffix };
-  }
-  /**
-   * Consume the literal `[]` suffix inside a substitution body.
-   * Called after the `[` has been detected (but not yet consumed).
-   * Requires the next character to be `[`, then exactly `]`, then `}`.
-   * Whitespace inside `[]` is not permitted (per spec Decision §1).
-   * Returns true (always — only called when listSuffix path is taken).
-   */
-  parseListSuffix(startLine) {
-    this.advance();
-    const afterBracket = this.peek();
-    if (afterBracket !== "]") {
-      const desc = afterBracket === "" ? "EOF" : JSON.stringify(afterBracket);
-      throw new ParseError(
-        `expected ']' after '[' in substitution list suffix (got ${desc})`,
-        startLine,
-        this.col
-      );
-    }
-    this.advance();
-    if (this.peek() !== "}") {
-      const desc = this.peek() === "" ? "EOF" : JSON.stringify(this.peek());
-      throw new ParseError(
-        `expected '}' after '[]' in substitution list suffix (got ${desc})`,
-        startLine,
-        this.col
-      );
-    }
-    this.advance();
-    return true;
-  }
-};
-function tokenize(input) {
-  return new Lexer(input).tokenize();
-}
-function isUnquotedSubstChar(ch) {
-  if (ch === "" || isHoconWhitespace(ch)) return false;
-  if ('"\\'.includes(ch)) return false;
-  if ("{}[]".includes(ch)) return false;
-  if (":=,+#`^?!@*&$.".includes(ch)) return false;
-  return true;
-}
-function isDecimalDigit(ch) {
-  return ch >= "0" && ch <= "9";
-}
-function isUnquotedStart(ch) {
-  if (ch === "" || isHoconWhitespace(ch)) return false;
-  if ('{}[],:=+#"$?!@*&^`\\'.includes(ch)) return false;
-  return true;
-}
-function isUnquotedContinue(ch, nextFn) {
-  if (ch === "" || isHoconWhitespace(ch)) return false;
-  if ('{}[],:=#"$?!@*&^`\\'.includes(ch)) return false;
-  if (ch === "+" && nextFn() === "=") return false;
-  if (ch === "/" && nextFn() === "/") return false;
-  return true;
-}
-
-// src/internal/parser/parser.ts
-var EOF_TOKEN = { kind: "eof", value: "", line: 0, col: 0, isQuoted: false, precedingSpace: false, precedingWhitespace: "", subst: void 0 };
-var Parser = class {
-  constructor(tokens) {
-    this.tokens = tokens;
-    this.pos = 0;
-  }
-  parse() {
-    this.skip("newline");
-    const t = this.peek();
-    if (t.kind === "lbrace") {
-      this.advance();
-      const first = this.parseObject(true);
-      const allFields = first.kind === "object" ? [...first.fields] : [];
-      while (true) {
-        this.skip("newline");
-        if (this.peek().kind === "eof") break;
-        if (this.peek().kind === "lbrace") {
-          this.advance();
-          const extra = this.parseObject(true);
-          if (extra.kind === "object") allFields.push(...extra.fields);
-        } else {
-          const rest = this.parseObject(false);
-          if (rest.kind === "object") allFields.push(...rest.fields);
-          break;
-        }
-      }
-      this.skip("newline");
-      const remaining2 = this.peek();
-      if (remaining2.kind !== "eof") {
-        throw new ParseError(`Unexpected token '${remaining2.value}' after closing brace`, remaining2.line, remaining2.col);
-      }
-      return { kind: "object", fields: allFields, pos: first.pos };
-    }
-    if (t.kind === "lbracket") {
-      this.advance();
-      const arr = this.parseArray();
-      this.skip("newline");
-      const remaining2 = this.peek();
-      if (remaining2.kind !== "eof") {
-        throw new ParseError(`Unexpected token '${remaining2.value}' after root array`, remaining2.line, remaining2.col);
-      }
-      return { ...arr, pos: { line: t.line, col: t.col } };
-    }
-    const root = this.parseObject(false);
-    this.skip("newline");
-    const remaining = this.peek();
-    if (remaining.kind !== "eof") {
-      throw new ParseError(`Unexpected token '${remaining.value}' after root content`, remaining.line, remaining.col);
-    }
-    return root;
-  }
-  peek(offset = 0) {
-    return this.tokens[this.pos + offset] ?? EOF_TOKEN;
-  }
-  advance() {
-    const t = this.tokens[this.pos];
-    if (this.pos < this.tokens.length) this.pos++;
-    return t ?? EOF_TOKEN;
-  }
-  skip(...kinds) {
-    while (kinds.includes(this.peek().kind)) this.advance();
-  }
-  currentPos() {
-    const t = this.peek();
-    return { line: t.line, col: t.col };
-  }
-  parseObject(expectClosingBrace) {
-    const p = this.currentPos();
-    const fields = [];
-    while (true) {
-      this.skip("newline");
-      const t = this.peek();
-      if (t.kind === "eof" || t.kind === "rbrace") break;
-      if (t.kind === "unquoted" && t.value === "include") {
-        const next = this.peek(1);
-        if (next.kind === "equals" || next.kind === "colon" || next.kind === "plus_equals" || next.kind === "lbrace") {
-          throw new ParseError(
-            `'include' is reserved at the start of a key path expression; use "include" (quoted) to use it as a key`,
-            t.line,
-            t.col
-          );
-        }
-        this.advance();
-        fields.push(this.parseInclude());
-        this.skip("newline");
-        if (this.peek().kind === "comma") this.advance();
-        this.skip("newline");
-        continue;
-      }
-      const keyPos = this.currentPos();
-      const { segments: key, firstWasQuoted } = this.parseKey();
-      if (key[0] === "include" && !firstWasQuoted) {
-        throw new ParseError(
-          `'include' is reserved at the start of a key path expression; use "include".foo (quoted) or rename the key`,
-          keyPos.line,
-          keyPos.col
-        );
-      }
-      this.skip("newline");
-      let append = false;
-      const sep = this.peek();
-      if (sep.kind === "equals") this.advance();
-      else if (sep.kind === "plus_equals") {
-        this.advance();
-        append = true;
-      } else if (sep.kind === "colon") this.advance();
-      else if (sep.kind === "lbrace") {
-      } else if (sep.kind !== "newline" && sep.kind !== "eof") {
-        throw new ParseError(`unexpected token after key: ${sep.kind}`, sep.line, sep.col);
-      }
-      this.skip("newline");
-      const value = this.parseValue();
-      fields.push({ key, value, append, pos: keyPos });
-      this.skip("newline");
-      if (this.peek().kind === "comma") this.advance();
-      this.skip("newline");
-    }
-    if (expectClosingBrace) {
-      const t = this.peek();
-      if (t.kind !== "rbrace") throw new ParseError("expected }", t.line, t.col);
-      this.advance();
-    }
-    return { kind: "object", fields, pos: p };
-  }
-  parseKey() {
-    const segments = [];
-    let trailingDot = false;
-    let firstWasQuoted = false;
-    let spaceConcat = false;
-    let postDotPrefix = "";
-    while (true) {
-      const t = this.peek();
-      if (t.kind === "string") {
-        this.advance();
-        if (segments.length === 0) firstWasQuoted = true;
-        if (spaceConcat) {
-          segments[segments.length - 1] = `${segments[segments.length - 1]}${t.precedingWhitespace}${t.value}`;
-        } else if (postDotPrefix !== "") {
-          segments.push(`${postDotPrefix}${t.value}`);
-          postDotPrefix = "";
-        } else {
-          segments.push(t.value);
-        }
-        trailingDot = false;
-      } else if (t.kind === "unquoted") {
-        this.advance();
-        const raw = t.value.startsWith(".") && segments.length > 0 && !t.precedingSpace ? t.value.slice(1) : t.value;
-        const parts = raw.split(".");
-        const leadingDotIsSeparator = spaceConcat || postDotPrefix !== "";
-        for (let i = 0; i < parts.length; i++) {
-          if (parts[i] !== "") continue;
-          if (i === parts.length - 1) continue;
-          if (i === 0 && leadingDotIsSeparator) continue;
-          throw new ParseError(
-            `path has ${i === 0 ? "a leading period '.'" : "two adjacent periods '.'"} \u2014 empty key segment not allowed, use quoted "" (HOCON.md path rules)`,
-            t.line,
-            t.col
-          );
-        }
-        const filtered = parts.filter((s) => s.length > 0);
-        if (spaceConcat) {
-          segments[segments.length - 1] = `${segments[segments.length - 1]}${t.precedingWhitespace}`;
-          if (raw.startsWith(".")) {
-            segments.push(...filtered);
-          } else if (filtered.length > 0) {
-            const [head, ...tail] = filtered;
-            segments[segments.length - 1] = `${segments[segments.length - 1]}${head}`;
-            segments.push(...tail);
-          }
-        } else if (postDotPrefix !== "" && raw.startsWith(".")) {
-          segments.push(postDotPrefix);
-          postDotPrefix = "";
-          segments.push(...filtered);
-        } else if (postDotPrefix !== "" && filtered.length > 0) {
-          const [head, ...tail] = filtered;
-          segments.push(`${postDotPrefix}${head}`, ...tail);
-          postDotPrefix = "";
-        } else {
-          segments.push(...filtered);
-        }
-        trailingDot = raw.endsWith(".");
-      } else {
-        if (segments.length === 0) throw new ParseError(`expected key, got ${t.kind}`, t.line, t.col);
-        break;
-      }
-      spaceConcat = false;
-      if (trailingDot) {
-        const next2 = this.peek();
-        if ((next2.kind === "unquoted" || next2.kind === "string") && next2.precedingWhitespace.length > 0) {
-          postDotPrefix = next2.precedingWhitespace;
-        } else {
-          postDotPrefix = "";
-        }
-        continue;
-      }
-      const next = this.peek();
-      if (next.kind === "unquoted" && next.value === "." && !next.precedingSpace) {
-        this.advance();
-        trailingDot = true;
-        const afterDot = this.peek();
-        if ((afterDot.kind === "unquoted" || afterDot.kind === "string") && afterDot.precedingWhitespace.length > 0) {
-          postDotPrefix = afterDot.precedingWhitespace;
-        }
-        continue;
-      }
-      if (next.kind === "unquoted" && next.value.startsWith(".") && !next.precedingSpace) {
-        trailingDot = true;
-        continue;
-      }
-      if ((next.kind === "unquoted" || next.kind === "string") && next.precedingSpace) {
-        spaceConcat = true;
-        continue;
-      }
-      break;
-    }
-    if (trailingDot) {
-      const here = this.peek();
-      throw new ParseError(
-        `path has a trailing period '.' \u2014 empty key segment not allowed (HOCON.md path rules)`,
-        here.line,
-        here.col
-      );
-    }
-    return { segments, firstWasQuoted };
-  }
-  parseInclude() {
-    const p = this.currentPos();
-    this.skip("newline");
-    const t = this.peek();
-    if (t.kind === "unquoted" && (t.value === "required(" || t.value === "required" || t.value.startsWith("required("))) {
-      if (t.value === "required") {
-        const next = this.peek(1);
-        if (next.kind !== "unquoted" || !next.value.startsWith("(")) {
-          throw new ParseError("include required must be followed by (", t.line, t.col);
-        }
-      }
-      this.advance();
-      const innerPrefix = t.value.startsWith("required(") ? t.value.slice("required(".length) : "";
-      if (innerPrefix === "url" || innerPrefix.startsWith("url(") || innerPrefix === "classpath" || innerPrefix.startsWith("classpath(")) {
-        throw new ParseError("include url(...) and classpath(...) are not supported", t.line, t.col);
-      }
-      const nextTok = this.peek();
-      if (innerPrefix === "package" || innerPrefix.startsWith("package(") || innerPrefix === "" && nextTok.kind === "unquoted" && (nextTok.value === "package(" || nextTok.value.startsWith("package("))) {
-        const consumePackageToken = innerPrefix === "";
-        const { qualifier, path: path3 } = this.parsePackageArgs(consumePackageToken);
-        return this.makeIncludeField(qualifier, path3, true, p);
-      }
-      if (innerPrefix === "file" || innerPrefix.startsWith("file(") || innerPrefix === "" && nextTok.kind === "unquoted" && (nextTok.value === "file(" || nextTok.value === "file")) {
-        if (innerPrefix === "") {
-          this.advance();
-        }
-        const path3 = this.parseQuotedPathSkipWrapper(t);
-        return this.makeIncludeField({ kind: "file" }, path3, true, p);
-      }
-      if (innerPrefix === "" && nextTok.kind === "unquoted" && (nextTok.value === "url" || nextTok.value.startsWith("url(") || nextTok.value === "classpath" || nextTok.value.startsWith("classpath("))) {
-        throw new ParseError("include url(...) and classpath(...) are not supported", nextTok.line, nextTok.col);
-      }
-      if (innerPrefix !== "") {
-        if (innerPrefix === ")") {
-          throw new ParseError("include required(...) must contain a path", t.line, t.col);
-        }
-        const name = innerPrefix.replace(/\(.*$/, "").replace(/\).*$/, "");
-        throw new ParseError(`unknown include qualifier inside required(): "${name}"`, t.line, t.col);
-      }
-      const path2 = this.parseQuotedPathSkipWrapper(t);
-      return this.makeIncludeField({ kind: "bare" }, path2, true, p);
-    }
-    if (t.kind === "string") {
-      const path2 = this.advance().value;
-      return this.makeIncludeField({ kind: "bare" }, path2, false, p);
-    }
-    if (t.kind === "unquoted" && (t.value === "file(" || t.value === "file")) {
-      this.advance();
-      const path2 = this.parseQuotedPathSkipWrapper(t);
-      return this.makeIncludeField({ kind: "file" }, path2, false, p);
-    }
-    if (t.kind === "unquoted" && (t.value === "package(" || t.value.startsWith("package("))) {
-      const { qualifier, path: path2 } = this.parsePackageArgs();
-      return this.makeIncludeField(qualifier, path2, false, p);
-    }
-    if (t.kind === "unquoted" && (t.value === "url" || t.value.startsWith("url("))) {
-      throw new ParseError("include url(...) is not supported", t.line, t.col);
-    }
-    if (t.kind === "unquoted" && (t.value === "classpath" || t.value.startsWith("classpath("))) {
-      throw new ParseError("include classpath(...) is not supported", t.line, t.col);
-    }
-    throw new ParseError(`expected include path, got ${t.kind}`, t.line, t.col);
-  }
-  makeIncludeField(qualifier, path2, required, pos) {
-    return { key: [], value: { kind: "include", qualifier, path: path2, required, pos }, append: false, pos };
-  }
-  /**
-   * Skip past include-syntax wrapper tokens to find the quoted path string.
-   * Strict: only allows `(`, `)`, and bare qualifier keywords (file / file( /
-   * package / package( / url / url( / classpath / classpath() between the
-   * directive and the quoted path. Anything else is a parse error rather than
-   * silently swallowed (see ts#113).
-   */
-  parseQuotedPathSkipWrapper(errTok) {
-    while (this.isIncludeWrapperToken(this.peek())) this.advance();
-    if (this.peek().kind !== "string") {
-      const tok = this.peek();
-      if (tok.kind === "eof") throw new ParseError("expected include path", errTok.line, errTok.col);
-      const desc = tok.kind === "unquoted" ? `unquoted "${tok.value}"` : tok.kind;
-      throw new ParseError(`expected quoted include path, got ${desc}`, tok.line, tok.col);
-    }
-    const path2 = this.advance().value;
-    while (this.peek().kind === "unquoted" && (this.peek().value === ")" || this.peek().value === "))")) {
-      this.advance();
-    }
-    const after = this.peek();
-    if (after.kind !== "newline" && after.kind !== "rbrace" && after.kind !== "eof" && after.kind !== "comma") {
-      const desc = after.kind === "unquoted" ? `unquoted "${after.value}"` : after.kind;
-      throw new ParseError(`unexpected token after include path: ${desc}`, after.line, after.col);
-    }
-    return path2;
-  }
-  isIncludeWrapperToken(tok) {
-    return tok.kind === "unquoted" && tok.value === "(";
-  }
-  /**
-   * Parse the body of `package("identifier", "file")`.
-   *
-   * @param consumePackageToken - When true (default), the current token is `package(` and
-   *   must be consumed first. When false, the lexer already bundled `package(` into the
-   *   preceding token (e.g. `required(package("`), so we are already positioned at the
-   *   first string argument.
-   */
-  parsePackageArgs(consumePackageToken = true) {
-    const pkgTok = consumePackageToken ? this.advance() : this.peek();
-    this.skip("newline");
-    const idTok = this.peek();
-    if (idTok.kind !== "string") {
-      throw new ParseError("include package: expected quoted identifier as first argument", pkgTok.line, pkgTok.col);
-    }
-    const identifier = this.advance().value;
-    this.skip("newline");
-    if (this.peek().kind !== "comma") {
-      const after = this.peek();
-      throw new ParseError(
-        after.kind === "string" ? "include package: missing comma between identifier and file arguments" : "include package: requires exactly two arguments (identifier, file) \u2014 one-arg form is not supported",
-        pkgTok.line,
-        pkgTok.col
-      );
-    }
-    this.advance();
-    this.skip("newline");
-    const fileTok = this.peek();
-    if (fileTok.kind !== "string") {
-      throw new ParseError(
-        "include package: requires exactly two arguments (identifier, file) \u2014 one-arg form is not supported",
-        pkgTok.line,
-        pkgTok.col
-      );
-    }
-    const filePath = this.advance().value;
-    while (this.peek().kind !== "newline" && this.peek().kind !== "rbrace" && this.peek().kind !== "eof" && this.peek().kind !== "comma") {
-      this.advance();
-    }
-    return { qualifier: { kind: "package", identifier }, path: filePath };
-  }
-  parseValue() {
-    const p = this.currentPos();
-    const parts = [];
-    while (true) {
-      const t = this.peek();
-      if (t.kind === "eof" || t.kind === "newline" || t.kind === "rbrace" || t.kind === "rbracket" || t.kind === "comma") break;
-      const hadSpace = t.precedingSpace && parts.length > 0;
-      let node;
-      if (t.kind === "lbrace") {
-        this.advance();
-        node = this.parseObject(true);
-      } else if (t.kind === "lbracket") {
-        this.advance();
-        node = this.parseArray();
-      } else if (t.kind === "subst") {
-        this.advance();
-        if (!t.subst) {
-          throw new ParseError(`internal: subst token missing payload`, t.line, t.col);
-        }
-        const payload = t.subst;
-        node = { kind: "subst", segments: payload.segments, optional: payload.optional, listSuffix: payload.listSuffix, pos: { line: t.line, col: t.col } };
-      } else if (t.kind === "string" || t.kind === "triple_string") {
-        this.advance();
-        node = { kind: "scalar", raw: t.value, valueType: "string", pos: { line: t.line, col: t.col } };
-      } else if (t.kind === "unquoted") {
-        this.advance();
-        node = { kind: "scalar", raw: t.value, valueType: this.scalarValueType(t.value), pos: { line: t.line, col: t.col } };
-      } else if ((t.kind === "colon" || t.kind === "equals") && parts.length > 0) {
-        this.advance();
-        node = { kind: "scalar", raw: t.value, valueType: "string", pos: { line: t.line, col: t.col } };
-      } else {
-        break;
-      }
-      if (hadSpace) {
-        const sep = t.precedingWhitespace.length > 0 ? t.precedingWhitespace : " ";
-        parts.push({ kind: "scalar", raw: sep, valueType: "string", pos: { line: t.line, col: t.col }, _separator: true });
-      }
-      parts.push(node);
-    }
-    if (parts.length === 0) throw new ParseError("expected value", this.peek().line, this.peek().col);
-    if (parts.length === 1) {
-      return parts[0];
-    }
-    return { kind: "concat", nodes: parts, pos: p };
-  }
-  parseArray() {
-    const p = this.currentPos();
-    const items = [];
-    while (true) {
-      this.skip("newline");
-      if (this.peek().kind === "rbracket" || this.peek().kind === "eof") break;
-      items.push(this.parseValue());
-      this.skip("newline");
-      if (this.peek().kind === "comma") this.advance();
-      this.skip("newline");
-    }
-    const t = this.peek();
-    if (t.kind !== "rbracket") throw new ParseError("expected ]", t.line, t.col);
-    this.advance();
-    return { kind: "array", items, pos: p };
-  }
-  scalarValueType(raw) {
-    if (raw === "true" || raw === "false") return "boolean";
-    if (raw === "null") return "null";
-    if (raw.length > 0 && (raw.charCodeAt(0) >= 48 && raw.charCodeAt(0) <= 57 || raw.charCodeAt(0) === 45)) {
-      if (DECIMAL_NUMBER_RE.test(raw)) return "number";
-    }
-    return "string";
-  }
-};
-function parseTokens(tokens) {
-  return new Parser(tokens).parse();
-}
-
-// src/internal/strip-bom.ts
-function stripBom(input) {
-  return input.charCodeAt(0) === 65279 ? input.slice(1) : input;
-}
-
-// src/internal/depth.ts
-var MAX_PATH_SEGMENTS = 64;
-function tooDeep(segments) {
-  return segments > MAX_PATH_SEGMENTS;
-}
-function guardStackDepth(fn, wrap) {
-  try {
-    return fn();
-  } catch (e) {
-    if (!isStackOverflow(e)) throw e;
-    throw wrap(STACK_MESSAGE);
-  }
-}
-var STACK_MESSAGE = "input is nested too deeply for this engine's stack, or contains a cycle (flatten the document, or break the cycle)";
-function isStackOverflow(e) {
-  if (!(e instanceof RangeError)) return false;
-  const m = e.message.toLowerCase();
-  return m.includes("call stack") || // V8: "Maximum call stack size exceeded"
-  m.includes("recursion") || // SpiderMonkey: "too much recursion"
-  m.includes("stack overflow");
-}
-function depthError(message) {
-  return new ConfigError(message, "");
-}
-async function guardStackDepthAsync(fn, wrap) {
-  try {
-    return await fn();
-  } catch (e) {
-    if (!isStackOverflow(e)) throw e;
-    throw wrap(STACK_MESSAGE);
-  }
-}
-
-// src/internal/properties/properties.ts
-function parseProperties(input) {
-  const pairs = [];
-  for (const { text, line } of logicalLines(stripBom(input))) {
-    const [rawKey, rawValue] = splitKeyValue(text);
-    const key = unescapeProps(rawKey, line);
-    if (key === "") continue;
-    const segments = key.split(".");
-    if (tooDeep(segments.length)) {
-      throw new ParseError(
-        `key maps to a path ${segments.length} segments deep, over the limit of ${MAX_PATH_SEGMENTS}`,
-        line,
-        1
-      );
-    }
-    pairs.push([segments, unescapeProps(rawValue, line)]);
-  }
-  return nestPairs(pairs);
-}
-function nestPairs(pairs) {
-  const root = /* @__PURE__ */ Object.create(null);
-  const sorted = [...pairs].sort(([a], [b]) => compareSegments(a, b));
-  for (const [segments, value] of sorted) {
-    setNested(root, segments, value);
-  }
-  return root;
-}
-function compareSegments(a, b) {
-  const n = Math.min(a.length, b.length);
-  for (let i = 0; i < n; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x !== y) return x < y ? -1 : 1;
-  }
-  return a.length - b.length;
-}
-function logicalLines(input) {
-  const natural = input.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
-  const out = [];
-  for (let i = 0; i < natural.length; i++) {
-    let text = trimLeadingSpace(natural[i] ?? "");
-    if (text === "" || text.startsWith("#") || text.startsWith("!")) continue;
-    const start = i + 1;
-    while (endsWithContinuation(text)) {
-      text = text.slice(0, -1);
-      if (i + 1 >= natural.length) break;
-      i++;
-      text += trimLeadingSpace(natural[i] ?? "");
-    }
-    out.push({ text, line: start });
-  }
-  return out;
-}
-function trimLeadingSpace(s) {
-  return s.replace(/^[ \t\f]+/, "");
-}
-function endsWithContinuation(line) {
-  let n = 0;
-  for (let i = line.length - 1; i >= 0 && line[i] === "\\"; i--) n++;
-  return n % 2 === 1;
-}
-function splitKeyValue(line) {
-  let key = "";
-  let i = 0;
-  for (; i < line.length; i++) {
-    const c = line[i];
-    if (c === "\\" && i + 1 < line.length) {
-      key += c + line[i + 1];
-      i++;
-      continue;
-    }
-    if (c === "=" || c === ":" || isPropsSpace(c)) break;
-    key += c;
-  }
-  while (i < line.length && isPropsSpace(line[i])) i++;
-  if (i < line.length && (line[i] === "=" || line[i] === ":")) {
-    i++;
-    while (i < line.length && isPropsSpace(line[i])) i++;
-  }
-  return [key, line.slice(i)];
-}
-function isPropsSpace(c) {
-  return c === " " || c === "	" || c === "\f";
-}
-function unescapeProps(s, line) {
-  let out = "";
-  for (let i = 0; i < s.length; i++) {
-    if (s[i] !== "\\") {
-      out += s[i];
-      continue;
-    }
-    i++;
-    if (i >= s.length) break;
-    const e = s[i];
-    switch (e) {
-      case "t":
-        out += "	";
-        break;
-      case "n":
-        out += "\n";
-        break;
-      case "r":
-        out += "\r";
-        break;
-      case "f":
-        out += "\f";
-        break;
-      case "u": {
-        const hex = s.slice(i + 1, i + 5);
-        if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
-          throw new ParseError(`malformed \\u escape in .properties: \\u${hex}`, line, i + 1);
-        }
-        out += String.fromCharCode(parseInt(hex, 16));
-        i += 4;
-        break;
-      }
-      default:
-        out += e;
-    }
-  }
-  return out;
-}
-function setNested(obj, segments, value) {
-  let current = obj;
-  for (let i = 0; i < segments.length - 1; i++) {
-    const seg = segments[i];
-    if (!(seg in current) || typeof current[seg] !== "object" || current[seg] === null) {
-      current[seg] = /* @__PURE__ */ Object.create(null);
-    }
-    current = current[seg];
-  }
-  const last = segments[segments.length - 1];
-  if (typeof current[last] === "object" && current[last] !== null) return;
-  current[last] = value;
-}
-function propertiesToHoconValue(input) {
-  const parsed = parseProperties(input);
-  return recordToHoconValue(parsed);
-}
-function recordToHoconValue(obj) {
-  const fields = /* @__PURE__ */ new Map();
-  for (const [key, val] of Object.entries(obj)) {
-    if (typeof val === "string") {
-      fields.set(key, { kind: "scalar", raw: val, valueType: "string" });
-    } else if (val !== null && typeof val === "object") {
-      fields.set(key, recordToHoconValue(val));
-    }
-  }
-  return { kind: "object", fields };
-}
-
-// src/internal/resolver/include-loader.ts
-var _require;
-function getRequire() {
-  if (_require === void 0) {
-    _require = pickRequire(
-      typeof __require === "function" ? __require : void 0,
-      import.meta.url
-    );
-  }
-  return _require;
-}
-function pickRequire(candidate, metaUrl) {
-  if (typeof candidate?.resolve === "function") {
-    return candidate;
-  }
-  return createRequire(metaUrl ?? pathToFileURL(nodePath.join(process.cwd(), "noop.js")));
-}
-function isPnpPath(p) {
-  return p.includes(".yarn/cache") || p.includes(".pnp.cjs") || p.includes(".pnp.loader");
-}
-function assertObjectRootedInclude(ast, sourcePath) {
-  if (ast.kind === "array") {
-    throw new ResolveError(
-      `included file has array at file root \u2014 an included file must contain an object, not an array (HOCON.md L993-994): ${sourcePath}`,
-      sourcePath,
-      ast.pos.line,
-      ast.pos.col
-    );
-  }
-}
-function validatePackageFile(file, identifier) {
-  if (file.length === 0) {
-    throw new ParseError(`include package("${identifier}", ...): file argument must be non-empty`, 0, 0);
-  }
-  if (file.includes("\\")) {
-    throw new ParseError(
-      `include package("${identifier}", "${file}"): backslash not allowed in file argument (use forward slash)`,
-      0,
-      0
-    );
-  }
-  if (file.startsWith("/")) {
-    throw new ParseError(
-      `include package("${identifier}", "${file}"): absolute path not allowed in file argument`,
-      0,
-      0
-    );
-  }
-  if (/(?:^|\/)\.\.?(?:\/|$)/u.test(file)) {
-    throw new ParseError(
-      `include package("${identifier}", "${file}"): path traversal (. or ..) not allowed in file argument`,
-      0,
-      0
-    );
-  }
-  if (file.includes("//")) {
-    throw new ParseError(
-      `include package("${identifier}", "${file}"): consecutive slashes not allowed in file argument`,
-      0,
-      0
-    );
-  }
-}
-function validatePackageIdentifier(identifier) {
-  if (identifier.length === 0) {
-    throw new ParseError("include package: identifier argument must be non-empty", 0, 0);
-  }
-}
-function defaultPackageResolver(identifier, file, includingFile, baseDir, resolveFrom) {
-  const from = resolveFrom ? Array.isArray(resolveFrom) ? resolveFrom : [resolveFrom] : baseDir ? [baseDir] : includingFile ? [nodePath.dirname(includingFile)] : [process.cwd()];
-  let resolved;
-  try {
-    resolved = getRequire().resolve(`${identifier}/${file}`, { paths: from });
-  } catch {
-    throw new PackageLookupError(
-      `include package("${identifier}", "${file}"): module not found (starting from: ${from.join(", ")})`,
-      identifier,
-      file,
-      0,
-      0
-    );
-  }
-  if (isPnpPath(resolved)) {
-    throw new ResolveError(
-      `include package("${identifier}", "${file}"): Yarn Berry PnP store paths are not supported. Provide a custom packageResolver option to handle PnP resolution.`,
-      `${identifier}/${file}`,
-      0,
-      0
-    );
-  }
-  const fileParts = file.split("/");
-  const expectedBasename = fileParts[fileParts.length - 1] ?? file;
-  const resolvedBasename = nodePath.basename(resolved);
-  if (resolvedBasename !== expectedBasename) {
-    throw new PackageLookupError(
-      `include package("${identifier}", "${file}"): case mismatch \u2014 resolved "${resolvedBasename}" but expected "${expectedBasename}" (E11 decision 5: case-sensitive)`,
-      identifier,
-      file,
-      0,
-      0
-    );
-  }
-  return resolved;
-}
-var IncludeLoader = class {
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /**
-   * Resolve an include path to an absolute path.
-   * - file() includes resolve relative to CWD (or as absolute paths),
-   *   NOT relative to the including file's directory.
-   * - Bare includes resolve relative to the including file's directory (baseDir).
-   */
-  resolveIncludePath(includePath, baseDir, isFile) {
-    return isFile ? nodePath.resolve(includePath) : baseDir ? nodePath.resolve(baseDir, includePath) : nodePath.resolve(includePath);
-  }
-  load(includePath, required, isFile) {
-    const { baseDir, includeStack = [] } = this.opts;
-    const absPath = this.resolveIncludePath(includePath, baseDir, !!isFile);
-    if (includeStack.includes(absPath)) {
-      throw new ResolveError(`circular include: ${absPath}`, absPath, 0, 0);
-    }
-    if (includeStack.length >= 50) {
-      throw new ResolveError(`include depth limit exceeded (max 50)`, includePath, 0, 0);
-    }
-    const hasExplicitExt = absPath.endsWith(".conf") || absPath.endsWith(".json") || absPath.endsWith(".properties");
-    if (hasExplicitExt) {
-      const result = this.loadSingle(absPath);
-      if (result !== void 0) return result;
-      if (required) {
-        throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
-      }
-      return makeResObj();
-    }
-    const merged = makeResObj();
-    let foundAny = false;
-    const probeExts = [".properties", ".json", ".conf"];
-    for (const ext of probeExts) {
-      const obj = this.loadSingle(`${absPath}${ext}`);
-      if (obj !== void 0) {
-        deepMergeResObjInto(merged, obj, []);
-        foundAny = true;
-      }
-    }
-    if (!foundAny && required) {
-      throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
-    }
-    return merged;
-  }
-  async loadAsync(includePath, required, isFile) {
-    const { baseDir, includeStack = [] } = this.opts;
-    const absPath = this.resolveIncludePath(includePath, baseDir, !!isFile);
-    if (includeStack.includes(absPath)) {
-      throw new ResolveError(`circular include: ${absPath}`, absPath, 0, 0);
-    }
-    if (includeStack.length >= 50) {
-      throw new ResolveError(`include depth limit exceeded (max 50)`, includePath, 0, 0);
-    }
-    const hasExplicitExt = absPath.endsWith(".conf") || absPath.endsWith(".json") || absPath.endsWith(".properties");
-    if (hasExplicitExt) {
-      const result = await this.loadSingleAsync(absPath);
-      if (result !== void 0) return result;
-      if (required) {
-        throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
-      }
-      return makeResObj();
-    }
-    const merged = makeResObj();
-    let foundAny = false;
-    const probeExts = [".properties", ".json", ".conf"];
-    for (const ext of probeExts) {
-      const obj = await this.loadSingleAsync(`${absPath}${ext}`);
-      if (obj !== void 0) {
-        deepMergeResObjInto(merged, obj, []);
-        foundAny = true;
-      }
-    }
-    if (!foundAny && required) {
-      throw new ResolveError(`required include file not found: ${includePath}`, includePath, 0, 0);
-    }
-    return merged;
-  }
-  /**
-   * Resolve and load `include package("identifier", "file")`.
-   * Validates the identifier and file arguments, resolves via the package resolver,
-   * performs cycle detection using a JSON-serialised cycle key, and parses the content.
-   */
-  // `required` is reserved for future optional-package semantics (E11 decision 7);
-  // currently all package lookup failures throw regardless of this flag.
-  loadPackage(identifier, file, _required) {
-    validatePackageIdentifier(identifier);
-    validatePackageFile(file, identifier);
-    const { includeStack = [], baseDir, resolveFrom, packageResolver, readFileSync: readFileSync2 } = this.opts;
-    const cycleKey = JSON.stringify(["package", identifier, file]);
-    if (includeStack.includes(cycleKey)) {
-      throw new ResolveError(
-        `circular include: package("${identifier}", "${file}")`,
-        `${identifier}/${file}`,
-        0,
-        0
-      );
-    }
-    if (includeStack.length >= 50) {
-      throw new ResolveError(`include depth limit exceeded (max 50)`, `${identifier}/${file}`, 0, 0);
-    }
-    const resolver = packageResolver ?? ((id, f, includingFile, bDir) => defaultPackageResolver(id, f, includingFile, bDir, resolveFrom));
-    const resolvedPath = resolver(identifier, file, void 0, baseDir);
-    const content = readFileSync2(resolvedPath);
-    const tokens = tokenize(content);
-    const ast = parseTokens(tokens);
-    assertObjectRootedInclude(ast, resolvedPath);
-    return this.onBuildResObj(ast, {
-      ...this.opts,
-      baseDir: nodePath.dirname(resolvedPath),
-      includeStack: [...includeStack, cycleKey]
-    });
-  }
-  /**
-   * Async variant of `loadPackage`.
-   */
-  async loadPackageAsync(identifier, file, _required) {
-    validatePackageIdentifier(identifier);
-    validatePackageFile(file, identifier);
-    const { includeStack = [], baseDir, resolveFrom, packageResolver, readFile, readFileSync: readFileSync2 } = this.opts;
-    const cycleKey = JSON.stringify(["package", identifier, file]);
-    if (includeStack.includes(cycleKey)) {
-      throw new ResolveError(
-        `circular include: package("${identifier}", "${file}")`,
-        `${identifier}/${file}`,
-        0,
-        0
-      );
-    }
-    if (includeStack.length >= 50) {
-      throw new ResolveError(`include depth limit exceeded (max 50)`, `${identifier}/${file}`, 0, 0);
-    }
-    const resolver = packageResolver ?? ((id, f, includingFile, bDir) => defaultPackageResolver(id, f, includingFile, bDir, resolveFrom));
-    const resolvedPath = resolver(identifier, file, void 0, baseDir);
-    const read = readFile ? async (p) => readFile(p) : async (p) => readFileSync2(p);
-    const content = await read(resolvedPath);
-    const tokens = tokenize(content);
-    const ast = parseTokens(tokens);
-    assertObjectRootedInclude(ast, resolvedPath);
-    return this.onBuildResObjAsync(ast, {
-      ...this.opts,
-      baseDir: nodePath.dirname(resolvedPath),
-      includeStack: [...includeStack, cycleKey]
-    });
-  }
-  loadSingle(candidate) {
-    const { readFileSync: readFileSync2, includeStack = [] } = this.opts;
-    if (includeStack.includes(candidate)) {
-      throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
-    }
-    let content;
-    try {
-      content = readFileSync2(candidate);
-    } catch (e) {
-      if (isFileNotFoundError(e)) return void 0;
-      throw e;
-    }
-    if (candidate.endsWith(".properties")) {
-      return hoconValueToResObj(propertiesToHoconValue(content));
-    }
-    const tokens = tokenize(content);
-    const ast = parseTokens(tokens);
-    assertObjectRootedInclude(ast, candidate);
-    return this.onBuildResObj(ast, {
-      ...this.opts,
-      baseDir: nodePath.dirname(candidate),
-      includeStack: [...includeStack, candidate]
-    });
-  }
-  async loadSingleAsync(candidate) {
-    const { readFile, readFileSync: readFileSync2, includeStack = [] } = this.opts;
-    const read = readFile ? async (p) => readFile(p) : async (p) => readFileSync2(p);
-    if (includeStack.includes(candidate)) {
-      throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
-    }
-    let content;
-    try {
-      content = await read(candidate);
-    } catch (e) {
-      if (isFileNotFoundError(e)) return void 0;
-      throw e;
-    }
-    if (candidate.endsWith(".properties")) {
-      return hoconValueToResObj(propertiesToHoconValue(content));
-    }
-    const tokens = tokenize(content);
-    const ast = parseTokens(tokens);
-    assertObjectRootedInclude(ast, candidate);
-    return this.onBuildResObjAsync(ast, {
-      ...this.opts,
-      baseDir: nodePath.dirname(candidate),
-      includeStack: [...includeStack, candidate]
-    });
-  }
-};
-
-// src/internal/resolver/structure-builder.ts
-var StructureBuilder = class _StructureBuilder {
-  constructor(opts) {
-    this.loader = new IncludeLoader(opts);
-    this.loader.onBuildResObj = (a, o) => new _StructureBuilder(o).build(a);
-    this.loader.onBuildResObjAsync = async (a, o) => new _StructureBuilder(o).buildAsync(a);
-  }
-  build(ast, pathPrefix = []) {
-    if (ast.kind !== "object") {
-      throw new ResolveError("root AST must be an object", "", ast.pos.line, ast.pos.col);
-    }
-    const obj = makeResObj();
-    for (const field of ast.fields) {
-      this.applyField(obj, field, pathPrefix);
-    }
-    return obj;
-  }
-  async buildAsync(ast, pathPrefix = []) {
-    if (ast.kind !== "object") {
-      throw new ResolveError("root AST must be an object", "", ast.pos.line, ast.pos.col);
-    }
-    const obj = makeResObj();
-    for (const field of ast.fields) {
-      await this.applyFieldAsync(obj, field, pathPrefix);
-    }
-    return obj;
-  }
-  applyField(obj, field, pathPrefix) {
-    if (field.key.length === 0 && field.value.kind === "include") {
-      const { qualifier, path: path2, required } = field.value;
-      let included;
-      if (qualifier.kind === "package") {
-        included = this.loader.loadPackage(qualifier.identifier, path2, required);
-      } else {
-        included = this.loader.load(path2, required, qualifier.kind === "file");
-      }
-      if (pathPrefix.length > 0) {
-        this.relativizeResObj(included, pathPrefix);
-      }
-      deepMergeResObjInto(obj, included, pathPrefix);
-      return;
-    }
-    const [head, ...tail] = field.key;
-    if (head === void 0) return;
-    if (tail.length > 0) {
-      const syntheticAst = {
-        kind: "object",
-        fields: [{ key: tail, value: field.value, append: field.append, pos: field.pos }],
-        pos: field.pos
-      };
-      this.applyField(obj, { key: [head], value: syntheticAst, append: false, pos: field.pos }, pathPrefix);
-      return;
-    }
-    const childPrefix = [...pathPrefix, head];
-    const fullKey = stringSegmentsToKey(childPrefix);
-    if (field.append) {
-      const synthetic = this.desugarAppend(field, childPrefix);
-      this.applyField(obj, synthetic, pathPrefix);
-      return;
-    }
-    const existing = obj.fields.get(head);
-    const newVal = this.astToResolverValue(field.value, childPrefix);
-    if (!containsSelfRef(newVal, fullKey)) {
-      obj.resetKeys.add(head);
-    }
-    if (existing !== void 0) {
-      const oldPrior = obj.priorValues.get(head);
-      const priorInput = isResObj(existing) ? foldNestedSelfRefs(existing, childPrefix) : existing;
-      const prior = foldOrSkipPrior(priorInput, fullKey, oldPrior);
-      if (prior !== void 0) obj.priorValues.set(head, prior);
-    }
-    if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
-      deepMergeResObjInto(existing, newVal, childPrefix);
-      return;
-    }
-    obj.fields.set(head, newVal);
-  }
-  async applyFieldAsync(obj, field, pathPrefix) {
-    if (field.key.length === 0 && field.value.kind === "include") {
-      const { qualifier, path: path2, required } = field.value;
-      let included;
-      if (qualifier.kind === "package") {
-        included = await this.loader.loadPackageAsync(qualifier.identifier, path2, required);
-      } else {
-        included = await this.loader.loadAsync(path2, required, qualifier.kind === "file");
-      }
-      if (pathPrefix.length > 0) {
-        this.relativizeResObj(included, pathPrefix);
-      }
-      deepMergeResObjInto(obj, included, pathPrefix);
-      return;
-    }
-    const [head, ...tail] = field.key;
-    if (head === void 0) return;
-    if (tail.length > 0) {
-      const syntheticAst = {
-        kind: "object",
-        fields: [{ key: tail, value: field.value, append: field.append, pos: field.pos }],
-        pos: field.pos
-      };
-      await this.applyFieldAsync(obj, { key: [head], value: syntheticAst, append: false, pos: field.pos }, pathPrefix);
-      return;
-    }
-    const childPrefix = [...pathPrefix, head];
-    const fullKey = stringSegmentsToKey(childPrefix);
-    if (field.append) {
-      const synthetic = this.desugarAppend(field, childPrefix);
-      await this.applyFieldAsync(obj, synthetic, pathPrefix);
-      return;
-    }
-    const existing = obj.fields.get(head);
-    const newVal = await this.astToResolverValueAsync(field.value, childPrefix);
-    if (!containsSelfRef(newVal, fullKey)) {
-      obj.resetKeys.add(head);
-    }
-    if (existing !== void 0) {
-      const oldPrior = obj.priorValues.get(head);
-      const priorInput = isResObj(existing) ? foldNestedSelfRefs(existing, childPrefix) : existing;
-      const prior = foldOrSkipPrior(priorInput, fullKey, oldPrior);
-      if (prior !== void 0) obj.priorValues.set(head, prior);
-    }
-    if (existing !== void 0 && isResObj(existing) && isResObj(newVal)) {
-      deepMergeResObjInto(existing, newVal, childPrefix);
-      return;
-    }
-    obj.fields.set(head, newVal);
-  }
-  /** Builds the `key = ${?fullkey} [value]` field that `key += value` desugars
-   * to (S13b.2, HOCON.md L732). `childPrefix` is the field's fully-qualified
-   * path (pathPrefix + key), so a nested `srv { items += x }` references
-   * `${?srv.items}`; include relativization rewrites it under a mount prefix.
-   * `field.key` is already single-segment here (multi-segment keys are split
-   * into nested objects upstream). Returns a NEW AstField (append=false);
-   * positions inherit from the original field so resolve-time errors (the
-   * S13b.2 non-array check, now via the scalar+array concat) keep a location. */
-  desugarAppend(field, childPrefix) {
-    const segments = childPrefix.map((text) => ({ text, line: field.pos.line, col: field.pos.col }));
-    const subst = { kind: "subst", segments, optional: true, listSuffix: false, pos: field.pos };
-    const elemArray = { kind: "array", items: [field.value], pos: field.pos };
-    const synthetic = { kind: "concat", nodes: [subst, elemArray], pos: field.pos };
-    return { key: field.key, value: synthetic, append: false, pos: field.pos };
-  }
-  astToResolverValue(ast, pathPrefix) {
-    switch (ast.kind) {
-      case "scalar": {
-        const sv = { kind: "scalar", raw: ast.raw, valueType: ast.valueType };
-        if (ast._separator) separatorValues.add(sv);
-        return sv;
-      }
-      case "array":
-        return { kind: "array", items: ast.items.map((i) => this.astToResolverValue(i, pathPrefix)) };
-      case "object": {
-        const inner = this.build(ast, pathPrefix);
-        return inner;
-      }
-      case "subst":
-        return { _kind: "subst-placeholder", segments: ast.segments, optional: ast.optional, knownAbsent: false, listSuffix: ast.listSuffix, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
-      case "concat":
-        return { _kind: "concat-placeholder", nodes: ast.nodes.map((n) => this.astToResolverValue(n, pathPrefix)), line: ast.pos.line, col: ast.pos.col };
-      case "include":
-        return { kind: "scalar", raw: "null", valueType: "null" };
-    }
-  }
-  async astToResolverValueAsync(ast, pathPrefix) {
-    switch (ast.kind) {
-      case "scalar": {
-        const sv = { kind: "scalar", raw: ast.raw, valueType: ast.valueType };
-        if (ast._separator) separatorValues.add(sv);
-        return sv;
-      }
-      case "array": {
-        const items = [];
-        for (const i of ast.items) {
-          items.push(await this.astToResolverValueAsync(i, pathPrefix));
-        }
-        return { kind: "array", items };
-      }
-      case "object":
-        return await this.buildAsync(ast, pathPrefix);
-      case "subst":
-        return { _kind: "subst-placeholder", segments: ast.segments, optional: ast.optional, knownAbsent: false, listSuffix: ast.listSuffix, line: ast.pos.line, col: ast.pos.col, prefixLen: 0 };
-      case "concat": {
-        const nodes = [];
-        for (const n of ast.nodes) {
-          nodes.push(await this.astToResolverValueAsync(n, pathPrefix));
-        }
-        return { _kind: "concat-placeholder", nodes, line: ast.pos.line, col: ast.pos.col };
-      }
-      case "include":
-        return { kind: "scalar", raw: "null", valueType: "null" };
-    }
-  }
-  // ---- Relativize substitution paths for nested includes ----
-  relativizeSubstPaths(val, prefixSegments) {
-    if (isSubst(val)) {
-      const prefixAsSegments = prefixSegments.map((text) => ({ text, line: 0, col: 0 }));
-      val.segments = [...prefixAsSegments, ...val.segments];
-      val.prefixLen += prefixSegments.length;
-      return;
-    }
-    if (isConcat(val)) {
-      for (const node of val.nodes) {
-        this.relativizeSubstPaths(node, prefixSegments);
-      }
-      return;
-    }
-    if (isResObj(val)) {
-      this.relativizeResObj(val, prefixSegments);
-      return;
-    }
-    const hv = val;
-    if (hv.kind === "array") {
-      for (const item of hv.items) {
-        this.relativizeSubstPaths(item, prefixSegments);
-      }
-    }
-  }
-  relativizeResObj(obj, prefixSegments) {
-    for (const val of obj.fields.values()) {
-      this.relativizeSubstPaths(val, prefixSegments);
-    }
-    for (const val of obj.priorValues.values()) {
-      this.relativizeSubstPaths(val, prefixSegments);
-    }
-  }
-};
-
-// src/value/numeric-array.ts
-function numericObjectToArray(value) {
-  if (value.kind !== "object") return null;
-  if (value.fields.size === 0) return null;
-  const canonicalInt = /^(0|[1-9][0-9]*)$/;
-  const eligible = [];
-  for (const [key, val] of value.fields) {
-    if (!canonicalInt.test(key)) continue;
-    const n = Number(key);
-    if (!Number.isInteger(n) || n > 2147483647) continue;
-    eligible.push({ n, v: val });
-  }
-  if (eligible.length === 0) return null;
-  eligible.sort((a, b) => a.n - b.n);
-  return eligible.map((e) => e.v);
-}
-
-// src/internal/resolver/substitution-resolver.ts
-var SubstitutionResolver = class {
-  constructor(root, opts) {
-    this.root = root;
-    this.opts = opts;
-    this.resolving = /* @__PURE__ */ new Set();
-    this.cache = /* @__PURE__ */ new Map();
-    // Tracks ConcatPlaceholder nodes currently being iterated by resolveConcat.
-    // Used by isSelfRef detection: fires only when found === a concat currently
-    // mid-iteration (i.e. we are inside found's own resolution), preventing the
-    // "foofoo" double-count without misfiring when an external field looks up the
-    // same concat via a substitution (multi-reviewer convergence fix).
-    //
-    // Spec deviation: the S13a.13 spec ★1 decision #1 specified path-equality
-    // preservation for self-ref detection. Round-2 multi-agent-review surfaced a
-    // false-positive on external lookups (`a = ${?a}foo; b = ${a}`), so the
-    // criterion was tightened to node-membership-in-iterating-set — strictly
-    // narrower than path-equality. Spec amendment deferred to a follow-up
-    // xx.hocon PR (see Phase 6 #3f close-out notes).
-    this.resolvingConcats = /* @__PURE__ */ new WeakSet();
-    // Path stack tracking the full dotted path of the field currently being
-    // assigned in `resolveResObj`. Leaf keys are pushed on entry to each
-    // `(key, val)` iteration and popped on exit, so nested objects build up
-    // the full path (e.g. `["o", "history"]` while resolving `o.history`).
-    //
-    // Used to tighten self-ref detection at the L192 found-lookup site:
-    // a substitution `${X}` whose looked-up value contains a Subst pointing
-    // at `X` is only a true self-reference when the field currently being
-    // assigned is `X` (or a descendant of `X`). Without this guard, an
-    // external lookup like `b = ${o}` (where o has a self-referential
-    // field) would mis-fire and short-circuit to o's prior, returning the
-    // wrong value for b. The is_owner gate (rfp prefix-matches s.segments)
-    // narrows the check to the owner case only.
-    //
-    // Cross-impl with rs.hocon v1.5.1's resolving_field_path (same purpose,
-    // same prefix-match semantics).
-    this.resolvingFieldPath = [];
-    // S13a.12 recursion guard: field keys whose prior is currently being
-    // resolved through the prefix-self-ref branch. Saved priors are
-    // prefix-self-ref-free by the fold invariant, so re-entry only happens on
-    // a shape the fold could not see through (a live subst mid-navigation) —
-    // report it as a cycle instead of recursing forever.
-    this.resolvingPrefixPriors = /* @__PURE__ */ new Set();
-  }
-  /** Returns a prefix for error messages, including origin info when set. */
-  originPrefix() {
-    return this.opts.originDescription ? `${this.opts.originDescription}: ` : "";
-  }
-  resolve() {
-    return this.resolveResObj(this.root);
-  }
-  resolveResObj(obj) {
-    const result = /* @__PURE__ */ new Map();
-    for (const [key, val] of obj.fields) {
-      this.resolvingFieldPath.push(key);
-      const fullCacheKey = stringSegmentsToKey(this.resolvingFieldPath);
-      this.cache.delete(fullCacheKey);
-      try {
-        const resolved = this.resolveVal(val, obj);
-        if (resolved !== void 0) {
-          if (resolved.kind === "object") {
-            const prior = obj.priorValues.get(key);
-            if (prior !== void 0) {
-              const priorResolved = this.resolveVal(prior, obj);
-              if (priorResolved !== void 0 && priorResolved.kind === "object") {
-                const finalValue = deepMergeHoconValues(
-                  priorResolved,
-                  resolved
-                );
-                result.set(key, finalValue);
-                this.cache.set(fullCacheKey, finalValue);
-                this.cacheDescendants(fullCacheKey, finalValue);
-                continue;
-              }
-            }
-          }
-          result.set(key, resolved);
-          this.cache.set(fullCacheKey, resolved);
-          this.cacheDescendants(fullCacheKey, resolved);
-        } else {
-          const prior = obj.priorValues.get(key);
-          if (prior !== void 0) {
-            const priorResolved = this.resolveVal(prior, obj);
-            if (priorResolved !== void 0) {
-              result.set(key, priorResolved);
-              this.cache.set(fullCacheKey, priorResolved);
-              this.cacheDescendants(fullCacheKey, priorResolved);
-            }
-          }
-        }
-      } finally {
-        this.resolvingFieldPath.pop();
-      }
-    }
-    return { kind: "object", fields: result };
-  }
-  /** S13a.12: walk resolved-object fields by segment text. A missing segment
-   * or a walk into a scalar/array is path-absent → undefined. */
-  navigateResolved(v, remainder) {
-    let cur = v;
-    for (const seg of remainder) {
-      if (cur.kind !== "object") return void 0;
-      const next = cur.fields.get(seg);
-      if (next === void 0) return void 0;
-      cur = next;
-    }
-    return cur;
-  }
-  cacheDescendants(prefix, value) {
-    if (value.kind !== "object") return;
-    for (const [key, child] of value.fields) {
-      const childKey = `${prefix}.${stringSegmentsToKey([key])}`;
-      this.cache.set(childKey, child);
-      this.cacheDescendants(childKey, child);
-    }
-  }
-  resolveVal(v, scope) {
-    if (isSubst(v)) return this.resolveSubst(v, scope);
-    if (isConcat(v)) {
-      this.resolvingConcats.add(v);
-      try {
-        const concatResult = this.resolveConcat(v.nodes, scope, v.line, v.col);
-        return concatResult;
-      } finally {
-        this.resolvingConcats.delete(v);
-      }
-    }
-    if (isResObj(v)) return this.resolveResObj(v);
-    const hv = v;
-    if (hv.kind === "array") {
-      const items = [];
-      for (const item of hv.items) {
-        const resolved = this.resolveVal(item, scope);
-        if (resolved === void 0) continue;
-        items.push(resolved);
-      }
-      return { kind: "array", items };
-    }
-    return hv;
-  }
-  resolveSubst(s, scope) {
-    if (s.knownAbsent) {
-      if (!s.optional) {
-        if (this.opts.allowUnresolved) return s;
-        const k = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
-        throw new ResolveError(
-          `${this.originPrefix()}could not resolve substitution: \${${k}}`,
-          k,
-          s.line,
-          s.col
-        );
-      }
-      return void 0;
-    }
-    {
-      const rfp = this.resolvingFieldPath;
-      const sTexts = s.segments.map((seg) => seg.text);
-      if (rfp.length > 0 && rfp.length < sTexts.length && stringSegmentsToKey(sTexts.slice(0, rfp.length)) === stringSegmentsToKey(rfp)) {
-        const guardKey = stringSegmentsToKey(rfp);
-        const prior = scope.priorValues.get(rfp[rfp.length - 1]);
-        if (prior !== void 0 && !this.resolvingPrefixPriors.has(guardKey)) {
-          this.resolvingPrefixPriors.add(guardKey);
-          try {
-            const priorResolved = this.resolveVal(prior, scope);
-            if (priorResolved !== void 0) {
-              const navigated = this.navigateResolved(priorResolved, sTexts.slice(rfp.length));
-              if (navigated !== void 0) return navigated;
-            }
-          } finally {
-            this.resolvingPrefixPriors.delete(guardKey);
-          }
-        }
-        if (s.optional) return void 0;
-        if (this.opts.allowUnresolved) return s;
-        const k = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
-        throw new ResolveError(
-          `${this.originPrefix()}could not resolve substitution: \${${k}}`,
-          k,
-          s.line,
-          s.col
-        );
-      }
-    }
-    const key = s.listSuffix ? `${segmentsToKey(s.segments)}[]` : segmentsToKey(s.segments);
-    if (this.cache.has(key)) return this.cache.get(key);
-    if (this.resolving.has(key)) {
-      let prior;
-      if (s.segments.length > 1) {
-        const leafSeg = s.segments[s.segments.length - 1]?.text ?? "";
-        const parentScope = lookupResObj(
-          this.root,
-          s.segments.slice(0, s.segments.length - 1)
-        );
-        prior = parentScope?.priorValues.get(leafSeg);
-      } else {
-        const rootSeg = s.segments[0]?.text ?? "";
-        prior = scope.priorValues.get(rootSeg) ?? this.root.priorValues.get(rootSeg);
-      }
-      if (prior !== void 0) {
-        const saved = this.resolving;
-        this.resolving = new Set(saved);
-        try {
-          return this.resolveVal(prior, scope);
-        } finally {
-          this.resolving = saved;
-        }
-      }
-      if (s.optional) return void 0;
-      throw new ResolveError(
-        this.originPrefix() + `circular substitution: ${key}`,
-        key,
-        s.line,
-        s.col
-      );
-    }
-    this.resolving.add(key);
-    try {
-      const found = lookupPath(this.root, s.segments);
-      if (found !== void 0) {
-        const rfp = this.resolvingFieldPath;
-        const isOwner = rfp.length >= s.segments.length && s.segments.every((seg, i) => rfp[i] === seg.text);
-        const isSelfRef = isConcat(found) && this.resolvingConcats.has(found) || isOwner && containsSubstByPath(found, s.segments);
-        if (isSelfRef) {
-          let prior;
-          if (s.segments.length > 1) {
-            const leafSeg = s.segments[s.segments.length - 1]?.text ?? "";
-            const parentScope = lookupResObj(
-              this.root,
-              s.segments.slice(0, s.segments.length - 1)
-            );
-            prior = parentScope?.priorValues.get(leafSeg);
-          } else {
-            const rootSeg = s.segments[0]?.text ?? "";
-            prior = scope.priorValues.get(rootSeg) ?? this.root.priorValues.get(rootSeg);
-          }
-          if (prior !== void 0) {
-            const result2 = this.resolveVal(prior, scope);
-            if (result2 !== void 0) this.cache.set(key, result2);
-            return result2;
-          }
-          if (s.optional) return void 0;
-          throw new ResolveError(
-            `${this.originPrefix()}could not resolve substitution: \${${key}}`,
-            key,
-            s.line,
-            s.col
-          );
-        }
-        let result = this.resolveVal(found, scope);
-        const effectiveLen = s.segments.length - s.prefixLen;
-        if (effectiveLen === 1 && result !== void 0 && result.kind === "object") {
-          const leafSeg = s.segments[s.segments.length - 1]?.text ?? "";
-          let prior;
-          if (s.prefixLen > 0) {
-            const parentScope = lookupResObj(
-              this.root,
-              s.segments.slice(0, s.segments.length - 1)
-            );
-            prior = parentScope?.priorValues.get(leafSeg);
-          } else {
-            prior = scope.priorValues.get(leafSeg) ?? this.root.priorValues.get(leafSeg);
-          }
-          if (prior !== void 0) {
-            const priorResolved = this.resolveVal(prior, scope);
-            if (priorResolved !== void 0 && priorResolved.kind === "object") {
-              result = deepMergeHoconValues(
-                priorResolved,
-                result
-              );
-            }
-          }
-        }
-        if (result !== void 0) this.cache.set(key, result);
-        return result;
-      }
-      if (s.prefixLen > 0 && s.segments.length > s.prefixLen) {
-        const originalSegments = s.segments.slice(s.prefixLen);
-        const fallbackFound = lookupPath(this.root, originalSegments);
-        if (fallbackFound !== void 0) {
-          let result = this.resolveVal(fallbackFound, scope);
-          if (originalSegments.length === 1 && result !== void 0 && result.kind === "object") {
-            const rootSeg = originalSegments[0]?.text ?? "";
-            const prior = this.root.priorValues.get(rootSeg);
-            if (prior !== void 0) {
-              const priorResolved = this.resolveVal(prior, scope);
-              if (priorResolved !== void 0 && priorResolved.kind === "object") {
-                result = deepMergeHoconValues(
-                  priorResolved,
-                  result
-                );
-              }
-            }
-          }
-          if (result !== void 0) this.cache.set(key, result);
-          return result;
-        }
-      }
-      if (s.listSuffix && this.opts.useSystemEnvironment !== false) {
-        const result = this.resolveEnvList(s);
-        if (result !== void 0) {
-          this.cache.set(key, result);
-          return result;
-        }
-        if (s.optional) return void 0;
-        const envBase = s.segments.map((seg) => seg.text).join(".");
-        throw new ResolveError(
-          `${this.originPrefix()}could not resolve substitution: \${${key}} (no environment variables ${envBase}_0, ${envBase}_1, \u2026 set)`,
-          key,
-          s.line,
-          s.col
-        );
-      } else if (s.listSuffix) {
-        if (s.optional) return void 0;
-        if (this.opts.allowUnresolved) return s;
-        throw new ResolveError(
-          `${this.originPrefix()}could not resolve substitution: \${${key}}`,
-          key,
-          s.line,
-          s.col
-        );
-      }
-      if (this.opts.useSystemEnvironment !== false) {
-        const envKey = s.segments.map((seg) => seg.text).join(".");
-        const envVal = this.opts.env[envKey] ?? (s.prefixLen > 0 ? this.opts.env[s.segments.slice(s.prefixLen).map((seg) => seg.text).join(".")] : void 0);
-        if (envVal !== void 0) {
-          const result = { kind: "scalar", raw: envVal, valueType: "string" };
-          this.cache.set(key, result);
-          return result;
-        }
-      }
-      if (s.optional) return void 0;
-      if (this.opts.allowUnresolved) {
-        return s;
-      }
-      throw new ResolveError(
-        `${this.originPrefix()}could not resolve substitution: \${${key}}`,
-        key,
-        s.line,
-        s.col
-      );
-    } finally {
-      this.resolving.delete(key);
-    }
-  }
-  /**
-   * S13c: scan environment for NAME_0, NAME_1, … and return an Array<Scalar(String)>.
-   *
-   * Candidate bases follow the same fully-qualified→bare order used by the scalar
-   * env fallback. The first base whose _0 key is present wins entirely — no
-   * cross-base merging (spec §Relativized fallback precedence rules).
-   *
-   * Returns the HoconValue Array if any candidate base has _0, or undefined if
-   * none do (caller applies optional/required handling).
-   */
-  resolveEnvList(s) {
-    const bases = this.candidateBases(s);
-    for (const base of bases) {
-      const key0 = base + "_0";
-      if (!(key0 in this.opts.env)) continue;
-      const items = [];
-      for (let i = 0; ; i++) {
-        const k = base + "_" + i;
-        if (!(k in this.opts.env)) break;
-        items.push({ kind: "scalar", raw: this.opts.env[k], valueType: "string" });
-      }
-      return { kind: "array", items };
-    }
-    return void 0;
-  }
-  /**
-   * Return the candidate base names for env-var-list lookup, in precedence order.
-   * Mirrors the fully-qualified→bare fallback used by the scalar env path.
-   */
-  candidateBases(s) {
-    const full = s.segments.map((seg) => seg.text).join(".");
-    if (s.prefixLen === 0) return [full];
-    const bare = s.segments.slice(s.prefixLen).map((seg) => seg.text).join(".");
-    return [full, bare];
-  }
-  resolveConcat(nodes, scope, line = 0, col = 0) {
-    const rawResolved = nodes.map((n) => this.resolveVal(n, scope));
-    if (this.opts.allowUnresolved) {
-      for (const v of rawResolved) {
-        if (v !== void 0 && isSubst(v)) {
-          return v;
-        }
-      }
-    }
-    const resolved = rawResolved.filter((v) => v !== void 0);
-    if (resolved.length === 0) return void 0;
-    if (resolved.length === 1) return resolved[0];
-    const nonSep = resolved.filter((v) => !separatorValues.has(v));
-    if (nonSep.length === 0) {
-      const str = resolved.map((v) => v.kind === "scalar" ? v.raw : JSON.stringify(v)).join("");
-      return { kind: "scalar", raw: str, valueType: "string" };
-    }
-    const joinPair = (left, right) => {
-      if (left.kind === "object" && right.kind === "object") {
-        return deepMergeHoconValues(left, right);
-      }
-      if (left.kind === "array" && right.kind === "object") {
-        const converted = numericObjectToArray(right);
-        if (converted !== null) {
-          return { kind: "array", items: [...left.items, ...converted] };
-        }
-        throw new ResolveError(
-          "cannot concatenate array with object: value concatenation requires same-kind operands (S10.4)",
-          "",
-          line,
-          col
-        );
-      }
-      if (left.kind === "object" && right.kind === "array") {
-        const converted = numericObjectToArray(left);
-        if (converted !== null) {
-          return { kind: "array", items: [...converted, ...right.items] };
-        }
-        throw new ResolveError(
-          "cannot concatenate object with array: value concatenation requires same-kind operands (S10.4)",
-          "",
-          line,
-          col
-        );
-      }
-      if (left.kind === "array" && right.kind === "array") {
-        return { kind: "array", items: [...left.items, ...right.items] };
-      }
-      if (left.kind === "array" || right.kind === "array") {
-        throw new ResolveError(
-          `cannot concatenate ${left.kind} with ${right.kind}: arrays and objects may not appear in string value concatenation (S10.13)`,
-          "",
-          line,
-          col
-        );
-      }
-      if (left.kind === "object" || right.kind === "object") {
-        throw new ResolveError(
-          `cannot concatenate ${left.kind} with ${right.kind}: arrays and objects may not appear in string value concatenation (S10.13)`,
-          "",
-          line,
-          col
-        );
-      }
-      return { kind: "scalar", raw: left.raw + right.raw, valueType: "string" };
-    };
-    const [head, ...tail] = nonSep;
-    const folded = tail.reduce(joinPair, head);
-    if (folded.kind === "scalar") {
-      const str = resolved.map((v) => v.kind === "scalar" ? v.raw : JSON.stringify(v)).join("");
-      return { kind: "scalar", raw: str, valueType: "string" };
-    }
-    return folded;
-  }
-};
-
-// src/internal/resolver/resolver.ts
-function buildTree(ast, opts) {
-  return new StructureBuilder(opts).build(ast);
-}
-function resolveTree(tree, opts) {
-  return new SubstitutionResolver(tree, opts).resolve();
-}
-function containsPlaceholders(tree) {
-  for (const val of tree.fields.values()) {
-    if (valContainsPlaceholders(val)) return true;
-  }
-  return false;
-}
-function valContainsPlaceholders(v) {
-  const rv = v;
-  if (isSubst(rv) || isConcat(rv)) return true;
-  if (isResObj(rv)) return containsPlaceholders(rv);
-  const hv = v;
-  if (hv?.kind === "array") {
-    return hv.items.some((item) => valContainsPlaceholders(item));
-  }
-  return false;
-}
-function buildPartialHoconFromResObj(tree) {
-  const fields = /* @__PURE__ */ new Map();
-  for (const [k, v] of tree.fields) {
-    if (!isSubst(v) && !isConcat(v)) {
-      if (isResObj(v)) {
-        fields.set(k, buildPartialHoconFromResObj(v));
-      } else {
-        if (!valContainsPlaceholders(v)) {
-          fields.set(k, v);
-        }
-      }
-    }
-  }
-  return { kind: "object", fields };
-}
-function hoconValueToResObj2(value) {
-  const obj = makeResObj();
-  for (const [k, v] of value.fields) {
-    if (v.kind === "object") {
-      obj.fields.set(k, hoconValueToResObj2(v));
-    } else {
-      obj.fields.set(k, v);
-    }
-  }
-  return obj;
-}
-function resolve2(ast, opts) {
-  const tree = buildTree(ast, opts);
-  return resolveTree(tree, { ...opts, useSystemEnvironment: true, allowUnresolved: false });
-}
-async function resolveAsync(ast, opts) {
-  const root = await new StructureBuilder(opts).buildAsync(ast);
-  return resolveTree(root, { ...opts, useSystemEnvironment: true, allowUnresolved: false });
-}
-
-// src/render-hocon.ts
-function renderHoconFromRoot(root) {
-  const out = [];
-  renderObjectBody(out, root, 0);
-  return out.join("");
-}
-function renderObjectBody(out, o, depth) {
-  const indent = "  ".repeat(depth);
-  for (const [k, v] of o.fields) {
-    out.push(indent, renderKey(k));
-    if (v.kind === "object") {
-      out.push(" {");
-      if (v.fields.size === 0) {
-        out.push("}\n");
-        continue;
-      }
-      out.push("\n");
-      renderObjectBody(out, v, depth + 1);
-      out.push(indent, "}\n");
-    } else {
-      out.push(" = ");
-      renderValue(out, v, depth);
-      out.push("\n");
-    }
-  }
-}
-function renderValue(out, v, depth) {
-  switch (v.kind) {
-    case "object": {
-      if (v.fields.size === 0) {
-        out.push("{}");
-        return;
-      }
-      out.push("{\n");
-      renderObjectBody(out, v, depth + 1);
-      out.push("  ".repeat(depth), "}");
-      return;
-    }
-    case "array":
-      renderArray(out, v, depth);
-      return;
-    case "scalar":
-      out.push(renderScalar(v));
-      return;
-    default:
-      throw new ConfigError(
-        "renderHocon: unrenderable value (config must be resolved data)",
-        ""
-      );
-  }
-}
-function renderArray(out, a, depth) {
-  if (a.items.length === 0) {
-    out.push("[]");
-    return;
-  }
-  const inner = "  ".repeat(depth + 1);
-  out.push("[\n");
-  for (const e of a.items) {
-    out.push(inner);
-    renderValue(out, e, depth + 1);
-    out.push("\n");
-  }
-  out.push("  ".repeat(depth), "]");
-}
-function renderScalar(s) {
-  switch (s.valueType) {
-    case "null":
-      return "null";
-    case "boolean":
-    case "number":
-      return s.raw;
-    case "string":
-      return renderString(s.raw);
-  }
-}
-var SAFE_UNQUOTED_KEY = /^[A-Za-z0-9_-]+$/;
-function renderKey(k) {
-  if (k === "include") return quoteString(k);
-  return SAFE_UNQUOTED_KEY.test(k) ? k : quoteString(k);
-}
-var SAFE_BARE_STRING = /^[A-Za-z][A-Za-z0-9_-]*$/;
-var STRING_KEYWORDS = /* @__PURE__ */ new Set(["true", "false", "null", "yes", "no", "on", "off"]);
-function renderString(s) {
-  return SAFE_BARE_STRING.test(s) && !STRING_KEYWORDS.has(s.toLowerCase()) ? s : quoteString(s);
-}
-function quoteString(s) {
-  if (s.includes("\n") && !s.includes("\r") && !s.includes('"""') && !s.endsWith('"')) {
-    return `"""${s}"""`;
-  }
-  let b = '"';
-  for (const ch of s) {
-    switch (ch) {
-      case '"':
-        b += '\\"';
-        break;
-      case "\\":
-        b += "\\\\";
-        break;
-      case "\n":
-        b += "\\n";
-        break;
-      case "\r":
-        b += "\\r";
-        break;
-      case "	":
-        b += "\\t";
-        break;
-      default:
-        b += ch;
-    }
-  }
-  return b + '"';
-}
-
-// src/config.ts
-var Config = class _Config {
-  constructor(root, opts) {
-    this.root = root;
-    this._resolved = opts?.resolved ?? true;
-    this._parseBaseDir = opts?.parseBaseDir;
-    this._originDescription = opts?.originDescription;
-    this._resObjRoot = opts?.resObjRoot;
-    this._resolveOpts = opts?.resolveOpts;
-  }
-  /** Returns true when the Config's value tree contains no unresolved
-   *  substitution placeholders. Whole-config granularity (E12 decision 11). */
-  isResolved() {
-    return this._resolved;
-  }
-  /** @internal Test-only: construct a resolved Config from a HoconValue. */
-  static _fromResolvedValue(root, opts) {
-    return new _Config(root, { resolved: true, originDescription: opts?.originDescription });
-  }
-  /** @internal Construct an unresolved Config carrying a ResObj tree.
-   *  Used by parseStringWithOptions (deferred path) in T6. */
-  static _fromUnresolvedResObj(tree, opts) {
-    const partialRoot = buildPartialHoconFromResObj(tree);
-    return new _Config(partialRoot, {
-      resolved: opts.resolved,
-      parseBaseDir: opts.parseBaseDir,
-      originDescription: opts.originDescription,
-      resObjRoot: tree,
-      resolveOpts: opts.resolveOpts
-    });
-  }
-  get(path2) {
-    const v = this.lookupNode(path2);
-    if (v === void 0) return void 0;
-    return hoconToJs(v);
-  }
-  /**
-   * Returns the raw {@link HoconValue} node at `path` as a deeply-immutable
-   * {@link ReadonlyHoconValue} view, or `undefined` if the path is absent. Unlike
-   * `get` (which decodes to a plain JS value), this exposes the value tree for
-   * structural introspection via the `value.ts` accessors (`asString`, `asObject`,
-   * `isScalar`, …).
-   *
-   * `getValue('')` returns the root object node.
-   *
-   * Throws {@link NotResolvedError} when the node (or its subtree) is unresolved:
-   * the `HoconValue` union has no placeholder variant, so an unresolved value
-   * cannot be represented. This matches `getConfig` / `getList`.
-   */
-  getValue(path2) {
-    const v = this.lookupNode(path2);
-    if (v === void 0) {
-      if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(path2)) {
-        throw new NotResolvedError(path2);
-      }
-      return void 0;
-    }
-    if (v.kind !== "scalar" && !this._resolved && this._resObjRootSubtreeHasPlaceholders(path2)) {
-      throw new NotResolvedError(path2);
-    }
-    return v;
-  }
-  getString(path2) {
-    const v = this.requireScalar(path2);
-    if (v.valueType === "null") {
-      throw new ConfigError(`expected string at ${path2}, got ${v.valueType}`, path2);
-    }
-    return v.raw;
-  }
-  getNumber(path2) {
-    const v = this.requireScalar(path2);
-    const coerced = coerceNumber(v.raw);
-    if (coerced !== void 0) return coerced;
-    throw new ConfigError(`expected number at ${path2}, got ${v.valueType}`, path2);
-  }
-  getBoolean(path2) {
-    const v = this.requireScalar(path2);
-    const coerced = coerceBoolean(v.raw);
-    if (coerced !== void 0) return coerced;
-    throw new ConfigError(`expected boolean at ${path2}, got ${v.valueType}`, path2);
-  }
-  getDuration(path2, unit) {
-    const v = this.requireScalar(path2);
-    if (v.valueType !== "string" && v.valueType !== "number") {
-      throw new ConfigError(`expected duration at ${path2}, got ${v.valueType}`, path2);
-    }
-    const result = parseDuration(v.raw, unit);
-    if (Number.isNaN(result)) throw new ConfigError(`invalid duration at ${path2}: ${JSON.stringify(v.raw)}`, path2);
-    return result;
-  }
-  getBytes(path2, unit) {
-    const v = this.requireScalar(path2);
-    if (v.valueType !== "string" && v.valueType !== "number") {
-      throw new ConfigError(`expected byte size at ${path2}, got ${v.valueType}`, path2);
-    }
-    const result = parseBytes(v.raw, unit);
-    if (Number.isNaN(result)) throw new ConfigError(`invalid byte size at ${path2}: ${JSON.stringify(v.raw)}`, path2);
-    if (result < 0) throw new ConfigError(`byte size must be non-negative at ${path2}: ${JSON.stringify(v.raw)}`, path2);
-    return result;
-  }
-  getConfig(path2) {
-    const v = this.lookupNode(path2);
-    if (v === void 0) {
-      if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(path2)) {
-        throw new NotResolvedError(path2);
-      }
-      throw new ConfigError(`path not found: ${path2}`, path2);
-    }
-    if (v.kind !== "object") throw new ConfigError(`expected object at ${path2}`, path2);
-    if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(path2)) {
-      throw new NotResolvedError(path2);
-    }
-    return new _Config(v, { resolved: this._resolved });
-  }
-  getList(path2) {
-    const v = this.lookupNode(path2);
-    if (v === void 0) {
-      if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(path2)) {
-        throw new NotResolvedError(path2);
-      }
-      throw new ConfigError(`path not found: ${path2}`, path2);
-    }
-    if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(path2)) {
-      throw new NotResolvedError(path2);
-    }
-    if (v.kind === "object") {
-      const converted = numericObjectToArray(v);
-      if (converted !== null) return converted.map((item) => hoconToJs(item));
-    }
-    if (v.kind !== "array") throw new ConfigError(`expected array at ${path2}`, path2);
-    return v.items.map((item) => hoconToJs(item));
-  }
-  has(path2) {
-    return this.lookupNode(path2) !== void 0;
-  }
-  keys() {
-    return [...this.root.fields.keys()];
-  }
-  withFallback(fallback) {
-    if (fallback == null) return this;
-    const selfTree = this._resObjRoot ?? hoconValueToResObj2(this.root);
-    const fbTree = fallback._resObjRoot ?? hoconValueToResObj2(fallback.root);
-    const merged = mergeUnresolved(selfTree, fbTree);
-    const hasPlaceholders = containsPlaceholders(merged);
-    const partialRoot = buildPartialHoconFromResObj(merged);
-    return new _Config(partialRoot, {
-      resolved: !hasPlaceholders,
-      parseBaseDir: this._parseBaseDir,
-      originDescription: this._originDescription,
-      resObjRoot: merged,
-      resolveOpts: this._resolveOpts ?? fallback._resolveOpts
-    });
-  }
-  /**
-   * Runs substitution resolution (phase 2) on the stored unresolved tree.
-   * Idempotent: calling resolve() on an already-resolved Config returns an
-   * equivalent resolved Config.
-   *
-   * opts.allowUnresolved (default false) — when true, leaves unresolved
-   * non-optional placeholders in place rather than throwing.
-   * opts.useSystemEnvironment (default true) — when false, env var lookups
-   * are suppressed (hermetic resolution).
-   *
-   * E12 decision 3.
-   */
-  resolve(opts = {}) {
-    if (this._resolved) {
-      return new _Config(this.root, {
-        resolved: true,
-        parseBaseDir: this._parseBaseDir,
-        originDescription: this._originDescription
-      });
-    }
-    const tree = this._resObjRoot;
-    if (!tree) {
-      return new _Config(this.root, { resolved: true });
-    }
-    const resolveOpts = {
-      ...this._resolveOpts ?? { env: {}, baseDir: void 0, readFileSync: () => {
-        throw new Error("no files");
-      } },
-      allowUnresolved: opts.allowUnresolved ?? false,
-      useSystemEnvironment: opts.useSystemEnvironment ?? true,
-      originDescription: this._originDescription
-    };
-    const resolved = resolveTree(tree, resolveOpts);
-    if (resolved.kind !== "object") throw new Error("resolve: expected object root");
-    if (opts.allowUnresolved) {
-      const { stripped, hadPlaceholders } = stripPlaceholderFields(resolved);
-      return new _Config(stripped, {
-        resolved: !hadPlaceholders,
-        parseBaseDir: this._parseBaseDir,
-        originDescription: this._originDescription,
-        resObjRoot: hadPlaceholders ? tree : void 0,
-        resolveOpts: hadPlaceholders ? resolveOpts : void 0
-      });
-    }
-    return new _Config(resolved, {
-      resolved: true,
-      parseBaseDir: this._parseBaseDir,
-      originDescription: this._originDescription
-    });
-  }
-  /**
-   * Resolves receiver substitutions using source as lookup context.
-   * Source's keys are NOT merged into the result — differs from
-   * `this.withFallback(source).resolve()` which includes source keys.
-   *
-   * Precondition (E12 decision 10): source must be resolved. If
-   * source.isResolved() is false, throws NotResolvedError.
-   *
-   * On an already-resolved receiver, resolveWith is a no-op (returns an
-   * equivalent resolved Config, source keys not included).
-   *
-   * E12 decisions 9, 10.
-   */
-  resolveWith(source, opts = {}) {
-    if (!source.isResolved()) {
-      throw new NotResolvedError("source");
-    }
-    if (this._resolved) {
-      return new _Config(this.root, {
-        resolved: true,
-        parseBaseDir: this._parseBaseDir,
-        originDescription: this._originDescription
-      });
-    }
-    const receiverTree = this._resObjRoot ?? hoconValueToResObj2(this.root);
-    const srcTree = hoconValueToResObj2(source.root);
-    const merged = mergeUnresolved(receiverTree, srcTree);
-    const resolveOpts = {
-      ...this._resolveOpts ?? { env: {}, baseDir: void 0, readFileSync: () => {
-        throw new Error("no files");
-      } },
-      allowUnresolved: opts.allowUnresolved ?? false,
-      useSystemEnvironment: opts.useSystemEnvironment ?? true,
-      originDescription: this._originDescription
-    };
-    const resolved = resolveTree(merged, resolveOpts);
-    if (resolved.kind !== "object") throw new Error("resolveWith: expected object root");
-    const receiverShapeForFilter = resObjToKeyShape(receiverTree);
-    const filtered = filterByReceiverShape(resolved, receiverShapeForFilter);
-    if (opts.allowUnresolved) {
-      const { stripped, hadPlaceholders } = stripPlaceholderFields(filtered);
-      return new _Config(stripped, {
-        resolved: !hadPlaceholders,
-        parseBaseDir: this._parseBaseDir,
-        originDescription: this._originDescription,
-        resObjRoot: hadPlaceholders ? receiverTree : void 0,
-        resolveOpts: hadPlaceholders ? resolveOpts : void 0
-      });
-    }
-    return new _Config(filtered, {
-      resolved: true,
-      parseBaseDir: this._parseBaseDir,
-      originDescription: this._originDescription
-    });
-  }
-  /**
-   * The whole config as plain JS data: objects, arrays, strings, numbers,
-   * booleans and `null`.
-   *
-   * Keys are reproduced exactly as the config carries them, `__proto__`,
-   * `constructor` and `prototype` included: each is defined as an **own data
-   * property**, so the returned object's prototype is always
-   * `Object.prototype`, and this call writes nothing to the global one.
-   *
-   * ### Passing the result to other code
-   *
-   * A config file — especially a `.properties` file or an env namespace you
-   * merged in — can therefore hand you an own `__proto__` key, and what happens
-   * next depends entirely on how the consumer copies it:
-   *
-   * ```ts
-   * const data = cfg.toObject()
-   * { ...data }                  // safe — own properties are copied as data
-   * structuredClone(data)        // safe
-   * Object.assign({}, data)      // NOT safe — [[Set]] on the {} target hits
-   *                              // Object.prototype's __proto__ setter: the key
-   *                              // vanishes and config data becomes the result's
-   *                              // prototype
-   * deepMerge({}, data)          // NOT safe — a naive recursive merge reads
-   *                              // target['__proto__'], gets Object.prototype,
-   *                              // and writes to it: global pollution
-   * for (const k in data) …      // prefer Object.entries / Object.keys
-   * ```
-   *
-   * Those two hazards come from the **destination** object's prototype, so no
-   * option here can disarm them — copy with spread or `structuredClone` instead.
-   *
-   * What `{ nullPrototype: true }` does give you is a result that inherits
-   * nothing: every object comes back with a `null` prototype, so reading
-   * `x.__proto__`, `x.constructor` or `x.toString` yields config data or
-   * `undefined` rather than something from `Object.prototype`, and code that
-   * merges *into* this object cannot climb out of it. Keys are all still
-   * present. The trade-off is the usual one for prototype-less objects: not
-   * `instanceof Object`, and no `hasOwnProperty` of their own.
-   *
-   * Numbers follow the JS number model, so an integer wider than 2^53 rounds
-   * here even when the config holds it exactly — read those with
-   * {@link Config.getString} instead.
-   */
-  toObject(opts) {
-    return hoconToJs(this.root, opts?.nullPrototype === true);
-  }
-  /**
-   * Renders this resolved Config as HOCON text (E18; lockstep with go.hocon's
-   * `Config.RenderHOCON`, v1.11.0).
-   *
-   * The output round-trips: parsing it back yields the same value tree. That
-   * is the correctness contract, not byte-for-byte formatting — a scalar is
-   * quoted whenever leaving it bare would re-parse as a different type (a
-   * string `"8080"` becomes `"8080"`, not `8080`), and left bare only when it
-   * provably cannot.
-   *
-   * The Config must be resolved and hold only data (objects, arrays, string /
-   * number / boolean / null scalars) — exactly what {@link fromMap} and the
-   * format adapters produce. An unresolved placeholder throws
-   * {@link ConfigError}; substitutions have no textual round trip through a
-   * value tree.
-   *
-   * The root object's fields are emitted without enclosing braces, nested
-   * objects as `key { … }`, arrays as newline-separated `[ … ]`, indented two
-   * spaces. Source comments are not represented — a value tree does not carry
-   * them.
-   */
-  renderHocon() {
-    if (!this._resolved) {
-      throw new ConfigError(
-        "renderHocon: unrenderable unresolved substitution (config must be resolved data)",
-        ""
-      );
-    }
-    return renderHoconFromRoot(this.root);
-  }
-  /**
-   * @internal Test-only: renders this resolved Config's value tree as canonical
-   * JSON (sorted keys, no whitespace). Used by Layer-2 fixture tests to compare
-   * against Lightbend ground truth. NOT part of the public API.
-   *
-   * Throws if the Config is unresolved (contains placeholders).
-   */
-  _renderJSONForTest() {
-    return renderHoconAsJSON(this.root);
-  }
-  lookupNode(path2) {
-    const segments = splitConfigPath(path2);
-    let current = this.root;
-    for (const seg of segments) {
-      if (current.kind !== "object") return void 0;
-      const next = current.fields.get(seg);
-      if (next === void 0) return void 0;
-      current = next;
-    }
-    return current;
-  }
-  /**
-   * _resObjRootSubtreeHasPlaceholders — walk _resObjRoot to the given path and
-   * return true if the subtree there contains any unresolved placeholder.
-   * Used by getConfig / getList (T2) to detect transitive unresolved placeholders
-   * in object / array subtrees that would otherwise appear to be "resolved" in the
-   * partial HoconValue root (because individual leaf fields are omitted rather than
-   * the whole subtree when their value is a direct placeholder scalar, but object
-   * sub-containers are retained in the partial root with the placeholder-keyed
-   * fields omitted from them — so the object appears "present but empty-ish").
-   */
-  _resObjRootSubtreeHasPlaceholders(path2) {
-    const tree = this._resObjRoot;
-    if (!tree) return false;
-    const segments = splitConfigPath(path2);
-    let cur = tree;
-    for (const seg of segments) {
-      const val = cur.fields.get(seg);
-      if (val === void 0) return false;
-      if (isResObj(val)) {
-        cur = val;
-      } else {
-        return valContainsPlaceholders(val);
-      }
-    }
-    return containsPlaceholders(cur);
-  }
-  requireScalar(path2) {
-    const v = this.lookupNode(path2);
-    if (v === void 0) {
-      if (!this._resolved && this._resObjRootSubtreeHasPlaceholders(path2)) {
-        throw new NotResolvedError(path2);
-      }
-      throw new ConfigError(`path not found: ${path2}`, path2);
-    }
-    if (v.kind !== "scalar") throw new ConfigError(`expected scalar at ${path2}, got ${v.kind}`, path2);
-    return v;
-  }
-};
-function splitConfigPath(path2) {
-  const segments = [];
-  let i = 0;
-  while (i < path2.length) {
-    if (path2[i] === '"') {
-      i++;
-      let segment = "";
-      let closed = false;
-      while (i < path2.length) {
-        const ch = path2[i];
-        if (ch === "\\" && i + 1 < path2.length) {
-          const next = path2[i + 1];
-          segment += next;
-          i += 2;
-          continue;
-        }
-        if (ch === '"') {
-          closed = true;
-          i++;
-          break;
-        }
-        segment += ch;
-        i++;
-      }
-      if (!closed) throw new ConfigError(`unterminated quoted path segment: ${path2}`, path2);
-      segments.push(segment);
-      if (i < path2.length && path2[i] === ".") i++;
-    } else {
-      const dot = path2.indexOf(".", i);
-      if (dot === -1) {
-        segments.push(path2.slice(i));
-        break;
-      }
-      segments.push(path2.slice(i, dot));
-      i = dot + 1;
-    }
-  }
-  return segments;
-}
-function scalarToJs(raw, valueType) {
-  switch (valueType) {
-    case "null":
-      return null;
-    case "boolean":
-      return raw === "true";
-    case "number":
-      return Number(raw);
-    case "string":
-      return raw;
-  }
-}
-function hoconToJs(v, nullPrototype = false) {
-  switch (v.kind) {
-    case "scalar":
-      return scalarToJs(v.raw, v.valueType);
-    case "array":
-      return v.items.map((item) => hoconToJs(item, nullPrototype));
-    case "object": {
-      const entries = Array.from(v.fields, ([k, val]) => [k, hoconToJs(val, nullPrototype)]);
-      if (nullPrototype) {
-        const obj = /* @__PURE__ */ Object.create(null);
-        for (const [k, val] of entries) Object.defineProperty(obj, k, {
-          value: val,
-          writable: true,
-          enumerable: true,
-          configurable: true
-        });
-        return obj;
-      }
-      return Object.fromEntries(entries);
-    }
-  }
-}
-function resObjToKeyShape(tree) {
-  const fields = /* @__PURE__ */ new Map();
-  for (const [k, v] of tree.fields) {
-    if (isSubst(v) || isConcat(v)) {
-      fields.set(k, { kind: "scalar", raw: "", valueType: "null" });
-    } else if (isResObj(v)) {
-      fields.set(k, resObjToKeyShape(v));
-    } else {
-      fields.set(k, v);
-    }
-  }
-  return { kind: "object", fields };
-}
-function stripPlaceholderFields(v) {
-  const fields = /* @__PURE__ */ new Map();
-  let hadPlaceholders = false;
-  for (const [k, val] of v.fields) {
-    if (val._kind === "subst-placeholder" || val._kind === "concat-placeholder") {
-      hadPlaceholders = true;
-    } else if (val.kind === "object") {
-      const inner = stripPlaceholderFields(val);
-      if (inner.hadPlaceholders) hadPlaceholders = true;
-      fields.set(k, inner.stripped);
-    } else {
-      fields.set(k, val);
-    }
-  }
-  return { stripped: { kind: "object", fields }, hadPlaceholders };
-}
-function filterByReceiverShape(resolved, receiverShape) {
-  const fields = /* @__PURE__ */ new Map();
-  for (const [k, rv] of resolved.fields) {
-    if (!receiverShape.fields.has(k)) continue;
-    const receiverVal = receiverShape.fields.get(k);
-    if (rv.kind === "object" && receiverVal.kind === "object") {
-      fields.set(k, filterByReceiverShape(rv, receiverVal));
-    } else {
-      fields.set(k, rv);
-    }
-  }
-  return { kind: "object", fields };
-}
-function renderHoconAsJSON(v) {
-  switch (v.kind) {
-    case "scalar": {
-      switch (v.valueType) {
-        case "null":
-          return "null";
-        case "boolean":
-          return v.raw;
-        case "number": {
-          const norm = normalizeLeadingZeroNumber(v.raw);
-          return JSON_NUMBER_RE.test(norm) ? norm : JSON.stringify(v.raw);
-        }
-        case "string":
-          return JSON.stringify(v.raw);
-      }
-      break;
-    }
-    case "array": {
-      const items = v.items.map(renderHoconAsJSON);
-      return `[${items.join(",")}]`;
-    }
-    case "object": {
-      const keys = [...v.fields.keys()].sort();
-      const pairs = keys.map((k) => {
-        const val = v.fields.get(k);
-        return `${JSON.stringify(k)}:${renderHoconAsJSON(val)}`;
-      });
-      return `{${pairs.join(",")}}`;
-    }
-  }
-  throw new Error(`renderHoconAsJSON: unsupported value kind (unresolved placeholder?)`);
-}
-var JSON_NUMBER_RE = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-function normalizeLeadingZeroNumber(raw) {
-  return raw.replace(/^([+-]?)0+(\d)/, "$1$2");
-}
-
-// src/parse.ts
-import * as fs from "fs";
-import * as path from "path";
-function defaultParseOptions() {
-  return { resolveSubstitutions: true };
-}
-function defaultResolveOptions() {
-  return { useSystemEnvironment: true, allowUnresolved: false };
-}
-function getEnv(opts) {
-  if (opts.env !== void 0) return opts.env;
-  if (typeof process !== "undefined" && process.env) return process.env;
-  return {};
-}
-function defaultReadFileSync(filePath) {
-  return fs.readFileSync(filePath, "utf-8");
-}
-async function defaultReadFile(filePath) {
-  return fs.promises.readFile(filePath, "utf-8");
-}
-function buildResolveContext(input, opts) {
-  const tokens = tokenize(input);
-  const ast = parseTokens(tokens);
-  if (ast.kind === "array") {
-    const origin = opts.originDescription ?? "input";
-    throw new ConfigError(
-      `${origin}: ${ast.pos.line}:${ast.pos.col}: document has type array rather than object at file root (HOCON.md L989-991); the Config API requires an object root`,
-      ""
-    );
-  }
-  const resolveOpts = {
-    env: getEnv(opts),
-    baseDir: opts.baseDir,
-    readFileSync: opts.readFileSync ?? defaultReadFileSync,
-    readFile: opts.readFile,
-    originDescription: opts.originDescription,
-    resolveFrom: opts.resolveFrom,
-    packageResolver: opts.packageResolver
-  };
-  return { ast, resolveOpts };
-}
-function parse(input, opts = {}) {
-  return parseStringWithOptions(input, opts);
-}
-var parseString = parse;
-function parseStringWithOptions(input, opts = {}) {
-  return guardStackDepth(
-    () => parseStringInner(input, opts),
-    (msg) => new ParseError(msg, 1, 1, opts.originDescription)
-  );
-}
-function parseStringInner(input, opts) {
-  const resolveSubstitutions = opts.resolveSubstitutions ?? true;
-  const { ast, resolveOpts } = buildResolveContext(input, opts);
-  if (resolveSubstitutions) {
-    const value = resolve2(ast, resolveOpts);
-    if (value.kind !== "object") throw new Error("resolved value is not an object");
-    return new Config(value, { resolved: true, originDescription: opts.originDescription });
-  }
-  const tree = buildTree(ast, resolveOpts);
-  const hasPlaceholders = containsPlaceholders(tree);
-  return Config._fromUnresolvedResObj(tree, {
-    parseBaseDir: opts.baseDir,
-    originDescription: opts.originDescription,
-    resolved: !hasPlaceholders,
-    resolveOpts
-  });
-}
-function parseFileWithOptions(filePath, opts = {}) {
-  if (typeof process === "undefined" && !opts.readFileSync) {
-    throw new Error("parseFileWithOptions is not supported in browser environments without opts.readFileSync.");
-  }
-  const resolvedPath = path.resolve(filePath);
-  const readFileSync2 = opts.readFileSync ?? defaultReadFileSync;
-  const input = readFileSync2(resolvedPath);
-  return parseStringWithOptions(input, {
-    ...opts,
-    baseDir: opts.baseDir ?? path.dirname(resolvedPath),
-    readFileSync: readFileSync2
-  });
-}
-async function parseAsync(input, opts = {}) {
-  return guardStackDepthAsync(async () => {
-    const { ast, resolveOpts } = buildResolveContext(input, opts);
-    const value = await resolveAsync(ast, resolveOpts);
-    if (value.kind !== "object") throw new Error("resolved value is not an object");
-    return new Config(value);
-  }, (msg) => new ParseError(msg, 1, 1, opts.originDescription));
-}
-function parseFile(filePath, opts = {}) {
-  if (typeof process === "undefined" && !opts.readFileSync) {
-    throw new Error("parseFile is not supported in browser environments. Provide opts.readFileSync or use parse() instead.");
-  }
-  const resolvedPath = path.resolve(filePath);
-  const readFileSync2 = opts.readFileSync ?? defaultReadFileSync;
-  const input = readFileSync2(resolvedPath);
-  return parse(input, {
-    ...opts,
-    baseDir: opts.baseDir ?? path.dirname(resolvedPath),
-    readFileSync: readFileSync2
-  });
-}
-async function parseFileAsync(filePath, opts = {}) {
-  if (typeof process === "undefined" && !opts.readFile) {
-    throw new Error("parseFileAsync is not supported in browser environments. Provide opts.readFile or use parseAsync() instead.");
-  }
-  const resolvedPath = path.resolve(filePath);
-  const readFile = opts.readFile ?? defaultReadFile;
-  const input = await readFile(resolvedPath);
-  return parseAsync(input, {
-    ...opts,
-    baseDir: opts.baseDir ?? path.dirname(resolvedPath),
-    readFile,
-    readFileSync: opts.readFileSync ?? defaultReadFileSync
-  });
-}
+import {
+  defaultParseOptions,
+  defaultResolveOptions,
+  parse,
+  parseAsync,
+  parseFile,
+  parseFileAsync,
+  parseFileWithOptions,
+  parseString,
+  parseStringWithOptions
+} from "./chunk-XWKO4JM3.js";
+import {
+  empty,
+  fromMap
+} from "./chunk-QY7ECGS6.js";
+import {
+  Config,
+  ConfigError,
+  NotResolvedError,
+  PackageLookupError,
+  ParseError,
+  ResolveError,
+  coerceBoolean,
+  coerceNumber
+} from "./chunk-WTXULUZS.js";
 
 // src/value.ts
 function asString(v) {
@@ -3683,78 +52,6 @@ function isScalar(v) {
 function isNull(v) {
   return v.kind === "scalar" && v.valueType === "null";
 }
-
-// src/value-factory.ts
-function fromMap(values, originDescription) {
-  const fields = guardStackDepth(
-    () => coerceObject(values, ""),
-    (msg) => depthError(`fromMap: ${msg}`)
-  );
-  const root = { kind: "object", fields };
-  return Config._fromResolvedValue(root, { originDescription });
-}
-function empty(originDescription) {
-  const root = { kind: "object", fields: /* @__PURE__ */ new Map() };
-  return Config._fromResolvedValue(root, { originDescription });
-}
-var INT64_MAX = 9223372036854775807n;
-var INT64_MIN = -9223372036854775808n;
-function coerceObject(obj, atPath) {
-  const fields = /* @__PURE__ */ new Map();
-  for (const [k, v] of Object.entries(obj)) {
-    const childPath = atPath ? `${atPath}.${k}` : k;
-    fields.set(k, coerceValue(v, childPath));
-  }
-  return fields;
-}
-function coerceValue(v, atPath) {
-  if (v === null) {
-    return { kind: "scalar", raw: "null", valueType: "null" };
-  }
-  if (v === void 0) {
-    throw new ConfigError(
-      `fromMap: undefined is not a valid HOCON value at path "${atPath}"`,
-      atPath
-    );
-  }
-  switch (typeof v) {
-    case "string":
-      return { kind: "scalar", raw: v, valueType: "string" };
-    case "number": {
-      if (Number.isNaN(v) || !Number.isFinite(v)) {
-        throw new ConfigError(
-          `fromMap: ${v} is not representable in HOCON (NaN/Infinity not allowed) at path "${atPath}"`,
-          atPath
-        );
-      }
-      return { kind: "scalar", raw: Object.is(v, -0) ? "-0" : String(v), valueType: "number" };
-    }
-    case "boolean":
-      return { kind: "scalar", raw: v ? "true" : "false", valueType: "boolean" };
-    case "bigint": {
-      if (v > INT64_MAX || v < INT64_MIN) {
-        throw new ConfigError(
-          `fromMap: integer ${v} is out of int64 range (HOCON integers are int64; spec F0.5) at path "${atPath}"`,
-          atPath
-        );
-      }
-      return { kind: "scalar", raw: String(v), valueType: "number" };
-    }
-    case "object": {
-      if (Array.isArray(v)) {
-        const items = v.map((item, i) => coerceValue(item, `${atPath}[${i}]`));
-        return { kind: "array", items };
-      }
-      const fields = coerceObject(v, atPath);
-      return { kind: "object", fields };
-    }
-    default:
-      throw new ConfigError(
-        `fromMap: unsupported value type "${typeof v}" at path "${atPath}"`,
-        atPath
-      );
-  }
-}
 export {
   Config,
   ConfigError,