@o3co/ts.hocon 0.1.0 → 0.1.1

package/src/internal/lexer/token.ts

@@ -1,20 +0,0 @@
-export type TokenKind =
-  | 'lbrace' | 'rbrace'
-  | 'lbracket' | 'rbracket'
-  | 'comma' | 'colon' | 'equals' | 'plus_equals'
-  | 'newline'
-  | 'string'         // "..." quoted string
-  | 'triple_string'  // """..."""
-  | 'unquoted'       // bare word, number, true/false/null
-  | 'subst'          // ${path}
-  | 'opt_subst'      // ${?path}
-  | 'eof'
-
-export type Token = {
-  kind: TokenKind
-  value: string           // always string; parser converts to number/bool/null
-  line: number
-  col: number
-  isQuoted: boolean       // true for "..." and """..."""
-  precedingSpace: boolean // true if preceded by whitespace (concat detection)
-}

package/src/internal/parser/ast.ts

@@ -1,17 +0,0 @@
-export type Pos = { line: number; col: number; file?: string }
-
-export type AstNode =
-  | { kind: 'object'; fields: AstField[]; pos: Pos }
-  | { kind: 'array'; items: AstNode[]; pos: Pos }
-  | { kind: 'scalar'; value: string | number | boolean | null; pos: Pos }
-  | { kind: 'concat'; nodes: AstNode[]; pos: Pos }
-  | { kind: 'subst'; path: string; optional: boolean; pos: Pos }
-  | { kind: 'include'; path: string; pos: Pos }
-
-// key が空配列のとき include ディレクティブを表す（value は include ノード）
-export type AstField = {
-  key: string[]     // 各要素はドット分割済み。quoted キーはドット分割しない
-  value: AstNode
-  append: boolean   // true なら += 演算子
-  pos: Pos
-}

package/src/internal/parser/parser.ts

@@ -1,229 +0,0 @@
-import { ParseError } from '../../errors.js'
-import type { Token } from '../lexer/token.js'
-import type { AstNode, AstField, Pos } from './ast.js'
-
-export function parseTokens(tokens: Token[]): AstNode {
-  let pos = 0
-
-  function peek(): Token { return tokens[pos] ?? { kind: 'eof', value: '', line: 0, col: 0, isQuoted: false, precedingSpace: false } }
-  function advance(): Token {
-    const t = tokens[pos]
-    if (pos < tokens.length) pos++
-    return t ?? { kind: 'eof', value: '', line: 0, col: 0, isQuoted: false, precedingSpace: false }
-  }
-  function skip(...kinds: string[]): void {
-    while (kinds.includes(peek().kind)) advance()
-  }
-
-  function currentPos(): Pos {
-    const t = peek()
-    return { line: t.line, col: t.col }
-  }
-
-  function parseObject(expectClosingBrace: boolean): AstNode {
-    const p = currentPos()
-    const fields: AstField[] = []
-
-    while (true) {
-      skip('newline')
-      const t = peek()
-      if (t.kind === 'eof' || t.kind === 'rbrace') break
-
-      // include directive
-      if (t.kind === 'unquoted' && t.value === 'include') {
-        advance()
-        fields.push(parseInclude())
-        // trailing separator after include
-        skip('newline')
-        if (peek().kind === 'comma') advance()
-        skip('newline')
-        continue
-      }
-
-      // key
-      const keyPos = currentPos()
-      const key = parseKey()
-
-      // value separator (optional)
-      skip('newline')
-      let append = false
-      const sep = peek()
-      if (sep.kind === 'equals') advance()
-      else if (sep.kind === 'plus_equals') { advance(); append = true }
-      else if (sep.kind === 'colon') advance()
-      else if (sep.kind === 'lbrace') { /* key { ... } shorthand — no advance, value parser handles it */ }
-      else if (sep.kind !== 'newline' && sep.kind !== 'eof') {
-        throw new ParseError(`unexpected token after key: ${sep.kind}`, sep.line, sep.col)
-      }
-
-      skip('newline')
-      const value = parseValue()
-      fields.push({ key, value, append, pos: keyPos })
-
-      // trailing separator
-      skip('newline')
-      if (peek().kind === 'comma') advance()
-      skip('newline')
-    }
-
-    if (expectClosingBrace) {
-      const t = peek()
-      if (t.kind !== 'rbrace') throw new ParseError('expected }', t.line, t.col)
-      advance()
-    }
-
-    return { kind: 'object', fields, pos: p }
-  }
-
-  function parseKey(): string[] {
-    const segments: string[] = []
-    let trailingDot = false
-    while (true) {
-      const t = peek()
-      if (t.kind === 'string') {
-        advance()
-        segments.push(t.value) // quoted: no dot split
-        trailingDot = false
-      } else if (t.kind === 'unquoted') {
-        advance()
-        // Split unquoted key at dots
-        const parts = t.value.split('.')
-        const filtered = parts.filter(s => s.length > 0)
-        segments.push(...filtered)
-        // If the unquoted value ended with a dot, the next token continues the key
-        trailingDot = t.value.endsWith('.')
-      } else {
-        if (segments.length === 0) throw new ParseError(`expected key, got ${t.kind}`, t.line, t.col)
-        break
-      }
-
-      // If the last unquoted segment ended with a dot, continue to next token
-      if (trailingDot) continue
-
-      // Check for explicit dot separator between segments (e.g. "a"."b")
-      // A lone dot as an unquoted token with no preceding space continues the key
-      const next = peek()
-      if (next.kind === 'unquoted' && next.value === '.' && !next.precedingSpace) {
-        advance() // consume the dot separator
-        trailingDot = true
-        continue
-      }
-
-      break
-    }
-    return segments
-  }
-
-  function parseInclude(): AstField {
-    const p = currentPos()
-    skip('newline')
-    const t = peek()
-    let path: string
-
-    if (t.kind === 'string') {
-      // include "path"
-      path = advance().value
-    } else if (t.kind === 'unquoted' && (t.value === 'file(' || t.value === 'file')) {
-      // include file("path")
-      advance()
-      // Skip tokens until we find the quoted path string
-      while (peek().kind !== 'string' && peek().kind !== 'eof') advance()
-      if (peek().kind === 'eof') throw new ParseError('expected include path', t.line, t.col)
-      path = advance().value
-      // Skip closing ) and anything else on this line
-      while (peek().kind !== 'newline' && peek().kind !== 'rbrace' && peek().kind !== 'eof') advance()
-    } else {
-      throw new ParseError(`expected include path, got ${t.kind}`, t.line, t.col)
-    }
-
-    return {
-      key: [],
-      value: { kind: 'include', path, pos: p },
-      append: false,
-      pos: p,
-    }
-  }
-
-  function parseValue(): AstNode {
-    const p = currentPos()
-    const parts: AstNode[] = []
-
-    while (true) {
-      const t = peek()
-      if (t.kind === 'eof' || t.kind === 'newline' || t.kind === 'rbrace' || t.kind === 'rbracket' || t.kind === 'comma') break
-
-      // If there was whitespace before this token and we already have parts,
-      // insert a space node for proper string concatenation.
-      const hadSpace = t.precedingSpace && parts.length > 0
-
-      let node: AstNode
-      if (t.kind === 'lbrace') {
-        advance()
-        node = parseObject(true)
-      } else if (t.kind === 'lbracket') {
-        advance()
-        node = parseArray()
-      } else if (t.kind === 'subst' || t.kind === 'opt_subst') {
-        advance()
-        node = { kind: 'subst', path: t.value, optional: t.kind === 'opt_subst', pos: { line: t.line, col: t.col } }
-      } else if (t.kind === 'string' || t.kind === 'triple_string') {
-        advance()
-        node = { kind: 'scalar', value: t.value, pos: { line: t.line, col: t.col } }
-      } else if (t.kind === 'unquoted') {
-        advance()
-        node = { kind: 'scalar', value: parseScalarValue(t.value), pos: { line: t.line, col: t.col } }
-      } else if ((t.kind === 'colon' || t.kind === 'equals') && parts.length > 0) {
-        // In value concat context, colon/equals after at least one part are plain string chars
-        // e.g.  url = ${host}:/path  or  x = ${a}=b
-        advance()
-        node = { kind: 'scalar', value: t.value, pos: { line: t.line, col: t.col } }
-      } else {
-        break
-      }
-      if (hadSpace) {
-        parts.push({ kind: 'scalar', value: ' ', pos: { line: t.line, col: t.col } })
-      }
-      parts.push(node)
-    }
-
-    if (parts.length === 0) throw new ParseError('expected value', peek().line, peek().col)
-    if (parts.length === 1) return parts[0]!
-    return { kind: 'concat', nodes: parts, pos: p }
-  }
-
-  function parseArray(): AstNode {
-    const p = currentPos()
-    const items: AstNode[] = []
-
-    while (true) {
-      skip('newline')
-      if (peek().kind === 'rbracket' || peek().kind === 'eof') break
-      items.push(parseValue())
-      skip('newline')
-      if (peek().kind === 'comma') advance()
-      skip('newline')
-    }
-
-    const t = peek()
-    if (t.kind !== 'rbracket') throw new ParseError('expected ]', t.line, t.col)
-    advance()
-    return { kind: 'array', items, pos: p }
-  }
-
-  function parseScalarValue(raw: string): string | number | boolean | null {
-    if (raw === 'true') return true
-    if (raw === 'false') return false
-    if (raw === 'null') return null
-    const n = Number(raw)
-    if (!isNaN(n) && raw.trim() !== '') return n
-    return raw
-  }
-
-  skip('newline')
-  const t = peek()
-  if (t.kind === 'lbrace') {
-    advance()
-    return parseObject(true)
-  }
-  return parseObject(false)
-}

package/src/internal/resolver/resolver.ts

@@ -1,428 +0,0 @@
-import * as nodePath from 'node:path'
-import { ResolveError } from '../../errors.js'
-import type { HoconValue } from '../../value.js'
-import type { AstNode, AstField } from '../parser/ast.js'
-import { tokenize } from '../lexer/lexer.js'
-import { parseTokens } from '../parser/parser.js'
-
-// ---- Internal placeholder types (not exported) ----
-type SubstPlaceholder = {
-  _kind: 'subst-placeholder'
-  path: string
-  optional: boolean
-  line: number
-  col: number
-}
-type ConcatPlaceholder = {
-  _kind: 'concat-placeholder'
-  nodes: ResolverValue[]
-}
-type AppendPlaceholder = {
-  _kind: 'append-placeholder'
-  existing: ResolverValue
-  elem: ResolverValue
-}
-type ResObj = {
-  _kind: 'res-obj'
-  fields: Map<string, ResolverValue>
-  priorValues: Map<string, ResolverValue>
-}
-
-type ResolverValue = HoconValue | SubstPlaceholder | ConcatPlaceholder | AppendPlaceholder | ResObj
-
-function isSubst(v: ResolverValue): v is SubstPlaceholder {
-  return (v as SubstPlaceholder)._kind === 'subst-placeholder'
-}
-function isConcat(v: ResolverValue): v is ConcatPlaceholder {
-  return (v as ConcatPlaceholder)._kind === 'concat-placeholder'
-}
-function isAppend(v: ResolverValue): v is AppendPlaceholder {
-  return (v as AppendPlaceholder)._kind === 'append-placeholder'
-}
-function isResObj(v: ResolverValue): v is ResObj {
-  return (v as ResObj)._kind === 'res-obj'
-}
-
-function makeResObj(): ResObj {
-  return { _kind: 'res-obj', fields: new Map(), priorValues: new Map() }
-}
-
-export type ResolveOptions = {
-  env: Record<string, string>
-  baseDir: string | undefined
-  readFileSync: (filePath: string) => string
-  includeStack?: string[]
-}
-
-// ---- Public entry point ----
-
-export function resolve(ast: AstNode, opts: ResolveOptions): HoconValue {
-  // Pass 1
-  const root = buildResObj(ast, opts)
-  // Pass 2
-  const resolving = new Set<string>()
-  const resolvedCache = new Map<string, HoconValue>()
-  return resolveResObj(root, root, resolving, resolvedCache, opts)
-}
-
-// ---- Pass 1: structure building ----
-
-function buildResObj(ast: AstNode, opts: ResolveOptions): ResObj {
-  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) {
-    applyField(obj, field, opts)
-  }
-  return obj
-}
-
-function applyField(obj: ResObj, field: AstField, opts: ResolveOptions): void {
-  // include directive: key is empty, value is include node
-  if (field.key.length === 0 && field.value.kind === 'include') {
-    const included = loadInclude(field.value.path, opts)
-    deepMergeResObjInto(obj, included)
-    return
-  }
-
-  const [head, ...tail] = field.key
-  if (!head) return
-
-  if (tail.length > 0) {
-    // Nested key: server.host = "x" → create synthetic object AST
-    const syntheticAst: AstNode = {
-      kind: 'object',
-      fields: [{ key: tail, value: field.value, append: field.append, pos: field.pos }],
-      pos: field.pos,
-    }
-    applyField(obj, { key: [head], value: syntheticAst, append: false, pos: field.pos }, opts)
-    return
-  }
-
-  if (field.append) {
-    // +=: append elem to existing array (or start from [])
-    const existing: ResolverValue = obj.fields.get(head) ?? ({ kind: 'array', items: [] } satisfies HoconValue)
-    obj.priorValues.set(head, existing)
-    obj.fields.set(head, {
-      _kind: 'append-placeholder',
-      existing,
-      elem: astToResolverValue(field.value, opts),
-    })
-    return
-  }
-
-  // Normal assignment
-  const existing = obj.fields.get(head)
-  const newVal = astToResolverValue(field.value, opts)
-
-  // Save prior value for self-referential substitution resolution
-  if (existing !== undefined) {
-    obj.priorValues.set(head, existing)
-  }
-
-  // Deep merge if both are ResObj
-  if (existing !== undefined && isResObj(existing) && isResObj(newVal)) {
-    deepMergeResObjInto(existing, newVal)
-    // existing already in fields — no re-set needed
-    return
-  }
-
-  obj.fields.set(head, newVal)
-}
-
-function astToResolverValue(ast: AstNode, opts: ResolveOptions): ResolverValue {
-  switch (ast.kind) {
-    case 'scalar':
-      return { kind: 'scalar', value: ast.value }
-    case 'array':
-      return { kind: 'array', items: ast.items.map(i => astToResolverValue(i, opts) as HoconValue) }
-    case 'object': {
-      const inner = buildResObj(ast, opts)
-      return inner
-    }
-    case 'subst':
-      return { _kind: 'subst-placeholder', path: ast.path, optional: ast.optional, line: ast.pos.line, col: ast.pos.col }
-    case 'concat':
-      return { _kind: 'concat-placeholder', nodes: ast.nodes.map(n => astToResolverValue(n, opts)) }
-    case 'include':
-      return { kind: 'scalar', value: null } // handled by applyField; should not reach here
-  }
-}
-
-function deepMergeResObjInto(dst: ResObj, src: ResObj): void {
-  for (const [k, srcVal] of src.fields) {
-    const dstVal = dst.fields.get(k)
-    if (dstVal !== undefined && isResObj(dstVal) && isResObj(srcVal)) {
-      deepMergeResObjInto(dstVal, srcVal)
-    } else {
-      if (dstVal !== undefined) dst.priorValues.set(k, dstVal)
-      dst.fields.set(k, srcVal)
-    }
-  }
-}
-
-// ---- Pass 2: substitution resolution ----
-
-function resolveResObj(
-  obj: ResObj,
-  root: ResObj,
-  resolving: Set<string>,
-  resolvedCache: Map<string, HoconValue>,
-  opts: ResolveOptions,
-): HoconValue {
-  const result = new Map<string, HoconValue>()
-  for (const [key, val] of obj.fields) {
-    const resolved = resolveVal(val, obj, root, resolving, resolvedCache, opts)
-    if (resolved !== undefined) result.set(key, resolved)
-  }
-  return { kind: 'object', fields: result }
-}
-
-function resolveVal(
-  v: ResolverValue,
-  scope: ResObj,
-  root: ResObj,
-  resolving: Set<string>,
-  resolvedCache: Map<string, HoconValue>,
-  opts: ResolveOptions,
-): HoconValue | undefined {
-  if (isSubst(v)) return resolveSubst(v, scope, root, resolving, resolvedCache, opts)
-  if (isConcat(v)) return resolveConcat(v.nodes, scope, root, resolving, resolvedCache, opts)
-  if (isAppend(v)) return resolveAppend(v, scope, root, resolving, resolvedCache, opts)
-  if (isResObj(v)) return resolveResObj(v, root, resolving, resolvedCache, opts)
-  const hv = v as HoconValue
-  if (hv.kind === 'array') {
-    return {
-      kind: 'array',
-      items: hv.items.map((item: HoconValue) =>
-        resolveVal(item as ResolverValue, scope, root, resolving, resolvedCache, opts)
-        ?? ({ kind: 'scalar', value: null } satisfies HoconValue)
-      ),
-    }
-  }
-  return hv
-}
-
-function resolveSubst(
-  s: SubstPlaceholder,
-  scope: ResObj,
-  root: ResObj,
-  resolving: Set<string>,
-  resolvedCache: Map<string, HoconValue>,
-  opts: ResolveOptions,
-): HoconValue | undefined {
-  if (resolvedCache.has(s.path)) return resolvedCache.get(s.path)!
-
-  if (resolving.has(s.path)) {
-    // Cycle detected: try prior value for self-referential substitutions.
-    // Look at the outermost (root) segment of the path in scope.priorValues first,
-    // then fall back to root-level priorValues.
-    const rootSeg = parseSubstPath(s.path)[0] ?? ''
-    const prior = scope.priorValues.get(rootSeg) ?? root.priorValues.get(rootSeg)
-    if (prior !== undefined) {
-      // Resolve prior with a fresh resolving set to avoid re-triggering the cycle check
-      return resolveVal(prior, scope, root, new Set(resolving), resolvedCache, opts)
-    }
-    if (s.optional) return undefined
-    throw new ResolveError(`circular substitution: ${s.path}`, s.path, s.line, s.col)
-  }
-
-  resolving.add(s.path)
-  try {
-    const found = lookupPath(root, parseSubstPath(s.path))
-    if (found !== undefined) {
-      // If the found value is still a subst/concat placeholder pointing at itself,
-      // use the prior value (self-referential overwrite case).
-      if (isSubst(found) || isConcat(found)) {
-        const rootSeg = parseSubstPath(s.path)[0] ?? ''
-        const prior = scope.priorValues.get(rootSeg) ?? root.priorValues.get(rootSeg)
-        if (prior !== undefined) {
-          const result = resolveVal(prior, scope, root, resolving, resolvedCache, opts)
-          if (result !== undefined) resolvedCache.set(s.path, result)
-          return result
-        }
-      }
-      const result = resolveVal(found, scope, root, resolving, resolvedCache, opts)
-      if (result !== undefined) resolvedCache.set(s.path, result)
-      return result
-    }
-
-    // Env var fallback
-    const envVal = opts.env[s.path]
-    if (envVal !== undefined) {
-      const result: HoconValue = { kind: 'scalar', value: envVal }
-      resolvedCache.set(s.path, result)
-      return result
-    }
-
-    if (s.optional) return undefined
-    throw new ResolveError(`could not resolve substitution: \${${s.path}}`, s.path, s.line, s.col)
-  } finally {
-    resolving.delete(s.path)
-  }
-}
-
-function resolveConcat(
-  nodes: ResolverValue[],
-  scope: ResObj,
-  root: ResObj,
-  resolving: Set<string>,
-  resolvedCache: Map<string, HoconValue>,
-  opts: ResolveOptions,
-): HoconValue {
-  const resolved = nodes
-    .map(n => resolveVal(n, scope, root, resolving, resolvedCache, opts))
-    .filter((v): v is HoconValue => v !== undefined)
-
-  if (resolved.length === 0) return { kind: 'scalar', value: null }
-  if (resolved.length === 1) return resolved[0]!
-
-  // Object concatenation: if all elements are objects, deep-merge them
-  if (resolved.every(v => v.kind === 'object')) {
-    const merged = new Map<string, HoconValue>()
-    for (const v of resolved) {
-      if (v.kind === 'object') {
-        for (const [k, val] of v.fields) {
-          merged.set(k, val)
-        }
-      }
-    }
-    return { kind: 'object', fields: merged }
-  }
-
-  // Array concatenation: if any element is an array, treat all as array elements
-  if (resolved.some(v => v.kind === 'array')) {
-    const items: HoconValue[] = []
-    for (const v of resolved) {
-      if (v.kind === 'array') items.push(...v.items)
-      else items.push(v)
-    }
-    return { kind: 'array', items }
-  }
-
-  // String concatenation
-  const str = resolved.map(v => v.kind === 'scalar' ? String(v.value) : JSON.stringify(v)).join('')
-  return { kind: 'scalar', value: str }
-}
-
-function resolveAppend(
-  a: AppendPlaceholder,
-  scope: ResObj,
-  root: ResObj,
-  resolving: Set<string>,
-  resolvedCache: Map<string, HoconValue>,
-  opts: ResolveOptions,
-): HoconValue {
-  const existing = resolveVal(a.existing, scope, root, resolving, resolvedCache, opts)
-    ?? ({ kind: 'array', items: [] } satisfies HoconValue)
-  const elem = resolveVal(a.elem, scope, root, resolving, resolvedCache, opts)
-  const items: HoconValue[] = existing.kind === 'array' ? [...existing.items] : [existing]
-  if (elem !== undefined) items.push(elem)
-  return { kind: 'array', items }
-}
-
-function lookupPath(root: ResObj, segments: string[]): ResolverValue | undefined {
-  const [head, ...tail] = segments
-  if (head === undefined || head === '') {
-    // For empty-string keys like "", try direct lookup
-    if (segments.length > 0) {
-      const val = root.fields.get('')
-      if (val === undefined) return undefined
-      if (tail.length === 0) return val
-      if (isResObj(val)) return lookupPath(val, tail)
-      return undefined
-    }
-    return undefined
-  }
-  const val = root.fields.get(head)
-  if (val === undefined) return undefined
-  if (tail.length === 0) return val
-  if (isResObj(val)) return lookupPath(val, tail)
-  return undefined
-}
-
-/**
- * Parse a substitution path that may contain quoted segments.
- * E.g. `"a.b.c"` → ["a.b.c"], `a.b.c` → ["a","b","c"],
- * `"".""."""` → ["","",""]
- */
-function parseSubstPath(raw: string): string[] {
-  const segments: string[] = []
-  let i = 0
-  while (i < raw.length) {
-    // Skip whitespace
-    while (i < raw.length && (raw[i] === ' ' || raw[i] === '\t')) i++
-    if (i >= raw.length) break
-
-    if (raw[i] === '"') {
-      // Quoted segment
-      i++ // skip opening quote
-      let seg = ''
-      while (i < raw.length && raw[i] !== '"') {
-        seg += raw[i]
-        i++
-      }
-      if (i < raw.length) i++ // skip closing quote
-      segments.push(seg)
-      // Skip whitespace and dot separator
-      while (i < raw.length && (raw[i] === ' ' || raw[i] === '\t')) i++
-      if (i < raw.length && raw[i] === '.') i++
-    } else if (raw[i] === '.') {
-      // Dot at start or after dot means empty-string segment
-      segments.push('')
-      i++
-    } else {
-      // Unquoted segment - read until dot or end
-      let seg = ''
-      while (i < raw.length && raw[i] !== '.') {
-        seg += raw[i]
-        i++
-      }
-      segments.push(seg.trim())
-      if (i < raw.length && raw[i] === '.') i++
-    }
-  }
-  return segments
-}
-
-function loadInclude(includePath: string, opts: ResolveOptions): ResObj {
-  const { baseDir, readFileSync, includeStack = [], env } = opts
-  const absPath = baseDir
-    ? nodePath.resolve(baseDir, includePath)
-    : nodePath.resolve(includePath)
-
-  if (includeStack.includes(absPath)) {
-    throw new ResolveError(`circular include: ${absPath}`, absPath, 0, 0)
-  }
-
-  // Try the path as-is, then with .conf and .json extensions
-  const candidates = [absPath]
-  if (!absPath.endsWith('.conf') && !absPath.endsWith('.json') && !absPath.endsWith('.properties')) {
-    candidates.push(absPath + '.conf', absPath + '.json')
-  }
-
-  for (const candidate of candidates) {
-    let content: string
-    try {
-      content = readFileSync(candidate)
-    } catch {
-      continue // file not found, try next candidate
-    }
-
-    if (includeStack.includes(candidate)) {
-      throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0)
-    }
-
-    const ast = parseTokens(tokenize(content))
-    return buildResObj(ast, {
-      env,
-      baseDir: nodePath.dirname(candidate),
-      readFileSync,
-      includeStack: [...includeStack, candidate],
-    })
-  }
-
-  // Missing includes are silently ignored per HOCON spec
-  return makeResObj()
-}