@o3co/ts.hocon 1.3.0 → 1.4.1

package/dist/zod.cjs

@@ -234,6 +234,10 @@ function parseBytes(value, outputUnit = "B") {
   return outputUnit === "B" ? Math.round(result) : result;
 }
 
+// src/parse.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+
 // src/errors.ts
 var ParseError = class extends Error {
   constructor(message, line, col, file) {
@@ -254,6 +258,14 @@ var ResolveError = class extends Error {
     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);
@@ -261,6 +273,156 @@ var ConfigError = class extends Error {
     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/types.ts
+var separatorValues = /* @__PURE__ */ new WeakSet();
+function isSubst(v) {
+  return v._kind === "subst-placeholder";
+}
+function isConcat(v) {
+  return v._kind === "concat-placeholder";
+}
+function isAppend(v) {
+  return v._kind === "append-placeholder";
+}
+function isResObj(v) {
+  return v._kind === "res-obj";
+}
+function makeResObj() {
+  return { _kind: "res-obj", fields: /* @__PURE__ */ new Map(), priorValues: /* @__PURE__ */ new Map() };
+}
+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;
+      }
+      result.priorValues.set(k, existing);
+    }
+    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) {
+  for (const [k, srcVal] of src.fields) {
+    const dstVal = dst.fields.get(k);
+    if (dstVal !== void 0 && isResObj(dstVal) && isResObj(srcVal)) {
+      deepMergeResObjInto(dstVal, srcVal);
+    } else {
+      if (dstVal !== void 0) dst.priorValues.set(k, dstVal);
+      dst.fields.set(k, srcVal);
+    }
+  }
+  for (const [k, srcPrior] of src.priorValues) {
+    if (!dst.priorValues.has(k)) {
+      dst.priorValues.set(k, srcPrior);
+    }
+  }
+}
+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
+var import_node_module = require("module");
+var nodePath = __toESM(require("path"), 1);
+
+// src/internal/parser/empty-check.ts
+function hasContentTokens(tokens) {
+  return tokens.some((t) => t.kind !== "eof" && t.kind !== "newline");
+}
+function assertNonEmptyDocument(tokens, sourceDescriptor) {
+  if (!hasContentTokens(tokens)) {
+    throw new ParseError(
+      `empty file is not a valid HOCON document (HOCON.md L130): ${sourceDescriptor}`,
+      1,
+      1
+    );
+  }
+}
 
 // src/internal/lexer/lexer.ts
 function isHoconWhitespace(ch) {
@@ -825,58 +987,137 @@ var Parser = class {
     const p = this.currentPos();
     this.skip("newline");
     const t = this.peek();
-    let path2;
-    let required = false;
-    let isFile = false;
     if (t.kind === "unquoted" && (t.value === "required(" || t.value === "required" || t.value.startsWith("required("))) {
       if (t.value === "required") {
-        const next2 = this.peek(1);
-        if (next2.kind !== "unquoted" || !next2.value.startsWith("(")) {
+        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);
         }
       }
-      required = true;
       this.advance();
       const innerPrefix = t.value.startsWith("required(") ? t.value.slice("required(".length) : "";
-      if (innerPrefix.startsWith("url") || innerPrefix.startsWith("classpath")) {
+      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);
       }
-      if (innerPrefix.startsWith("file")) {
-        isFile = true;
+      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);
       }
-      const next = this.peek();
-      if (next.kind === "unquoted" && (next.value === "url" || next.value.startsWith("url(") || next.value === "classpath" || next.value.startsWith("classpath("))) {
-        throw new ParseError("include url(...) and classpath(...) are not supported", next.line, next.col);
-      }
-      if (next.kind === "unquoted" && (next.value === "file(" || next.value === "file" || next.value.startsWith("file("))) {
-        isFile = true;
-      }
-      while (this.peek().kind !== "string" && this.peek().kind !== "eof") this.advance();
-      if (this.peek().kind === "eof") throw new ParseError("expected include path", t.line, t.col);
-      path2 = this.advance().value;
-      while (this.peek().kind !== "newline" && this.peek().kind !== "rbrace" && this.peek().kind !== "eof" && this.peek().kind !== "comma") this.advance();
-    } else if (t.kind === "string") {
-      path2 = this.advance().value;
-    } else if (t.kind === "unquoted" && (t.value === "file(" || t.value === "file")) {
-      isFile = true;
+      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();
-      while (this.peek().kind !== "string" && this.peek().kind !== "eof") this.advance();
-      if (this.peek().kind === "eof") throw new ParseError("expected include path", t.line, t.col);
-      path2 = this.advance().value;
-      while (this.peek().kind !== "newline" && this.peek().kind !== "rbrace" && this.peek().kind !== "eof" && this.peek().kind !== "comma") this.advance();
-    } else if (t.kind === "unquoted" && (t.value === "url" || t.value.startsWith("url("))) {
+      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);
-    } else if (t.kind === "unquoted" && (t.value === "classpath" || t.value.startsWith("classpath("))) {
+    }
+    if (t.kind === "unquoted" && (t.value === "classpath" || t.value.startsWith("classpath("))) {
       throw new ParseError("include classpath(...) is not supported", t.line, t.col);
-    } else {
-      throw new ParseError(`expected include path, got ${t.kind}`, t.line, t.col);
     }
-    return {
-      key: [],
-      value: { kind: "include", path: path2, required, ...isFile ? { isFile: true } : {}, pos: p },
-      append: false,
-      pos: p
-    };
+    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();
@@ -917,7 +1158,9 @@ var Parser = class {
       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];
+    if (parts.length === 1) {
+      return parts[0];
+    }
     return { kind: "concat", nodes: parts, pos: p };
   }
   parseArray() {
@@ -949,118 +1192,6 @@ function parseTokens(tokens) {
   return new Parser(tokens).parse();
 }
 
-// src/internal/parser/empty-check.ts
-function hasContentTokens(tokens) {
-  return tokens.some((t) => t.kind !== "eof" && t.kind !== "newline");
-}
-function assertNonEmptyDocument(tokens, sourceDescriptor) {
-  if (!hasContentTokens(tokens)) {
-    throw new ParseError(
-      `empty file is not a valid HOCON document (HOCON.md L130): ${sourceDescriptor}`,
-      1,
-      1
-    );
-  }
-}
-
-// 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 isAppend(v) {
-  return v._kind === "append-placeholder";
-}
-function isResObj(v) {
-  return v._kind === "res-obj";
-}
-function makeResObj() {
-  return { _kind: "res-obj", fields: /* @__PURE__ */ new Map(), priorValues: /* @__PURE__ */ new Map() };
-}
-
-// 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) {
-  for (const [k, srcVal] of src.fields) {
-    const dstVal = dst.fields.get(k);
-    if (dstVal !== void 0 && isResObj(dstVal) && isResObj(srcVal)) {
-      deepMergeResObjInto(dstVal, srcVal);
-    } else {
-      if (dstVal !== void 0) dst.priorValues.set(k, dstVal);
-      dst.fields.set(k, srcVal);
-    }
-  }
-  for (const [k, srcPrior] of src.priorValues) {
-    if (!dst.priorValues.has(k)) {
-      dst.priorValues.set(k, srcPrior);
-    }
-  }
-}
-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
-var nodePath = __toESM(require("path"), 1);
-
 // src/internal/properties/properties.ts
 function parseProperties(input) {
   const root = /* @__PURE__ */ Object.create(null);
@@ -1120,6 +1251,85 @@ function recordToHoconValue(obj) {
 }
 
 // src/internal/resolver/include-loader.ts
+var import_meta = {};
+var _require = (0, import_node_module.createRequire)(import_meta.url);
+function isPnpPath(p) {
+  return p.includes(".yarn/cache") || p.includes(".pnp.cjs") || p.includes(".pnp.loader");
+}
+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 = _require.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;
@@ -1199,8 +1409,77 @@ var IncludeLoader = class {
     }
     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);
+    if (content.length === 0) return makeResObj();
+    const tokens = tokenize(content);
+    assertNonEmptyDocument(tokens, resolvedPath);
+    const ast = parseTokens(tokens);
+    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);
+    if (content.length === 0) return makeResObj();
+    const tokens = tokenize(content);
+    assertNonEmptyDocument(tokens, resolvedPath);
+    const ast = parseTokens(tokens);
+    return this.onBuildResObjAsync(ast, {
+      ...this.opts,
+      baseDir: nodePath.dirname(resolvedPath),
+      includeStack: [...includeStack, cycleKey]
+    });
+  }
   loadSingle(candidate) {
-    const { readFileSync: readFileSync2, includeStack = [], env } = this.opts;
+    const { readFileSync: readFileSync2, includeStack = [] } = this.opts;
     if (includeStack.includes(candidate)) {
       throw new ResolveError(`circular include: ${candidate}`, candidate, 0, 0);
     }
@@ -1215,17 +1494,18 @@ var IncludeLoader = class {
       return hoconValueToResObj(propertiesToHoconValue(content));
     }
     const tokens = tokenize(content);
-    assertNonEmptyDocument(tokens, candidate);
+    if (!hasContentTokens(tokens)) {
+      return makeResObj();
+    }
     const ast = parseTokens(tokens);
     return this.onBuildResObj(ast, {
-      env,
+      ...this.opts,
       baseDir: nodePath.dirname(candidate),
-      readFileSync: readFileSync2,
       includeStack: [...includeStack, candidate]
     });
   }
   async loadSingleAsync(candidate) {
-    const { readFile, readFileSync: readFileSync2, includeStack = [], env } = this.opts;
+    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);
@@ -1241,13 +1521,13 @@ var IncludeLoader = class {
       return hoconValueToResObj(propertiesToHoconValue(content));
     }
     const tokens = tokenize(content);
-    assertNonEmptyDocument(tokens, candidate);
+    if (!hasContentTokens(tokens)) {
+      return makeResObj();
+    }
     const ast = parseTokens(tokens);
     return this.onBuildResObjAsync(ast, {
-      env,
+      ...this.opts,
       baseDir: nodePath.dirname(candidate),
-      readFileSync: readFileSync2,
-      readFile,
       includeStack: [...includeStack, candidate]
     });
   }
@@ -1256,7 +1536,6 @@ var IncludeLoader = class {
 // src/internal/resolver/structure-builder.ts
 var StructureBuilder = class _StructureBuilder {
   constructor(opts) {
-    this.opts = 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);
@@ -1283,7 +1562,13 @@ var StructureBuilder = class _StructureBuilder {
   }
   applyField(obj, field, pathPrefix) {
     if (field.key.length === 0 && field.value.kind === "include") {
-      const included = this.loader.load(field.value.path, field.value.required, field.value.isFile);
+      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);
       }
@@ -1325,7 +1610,13 @@ var StructureBuilder = class _StructureBuilder {
   }
   async applyFieldAsync(obj, field, pathPrefix) {
     if (field.key.length === 0 && field.value.kind === "include") {
-      const included = await this.loader.loadAsync(field.value.path, field.value.required, field.value.isFile);
+      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);
       }
@@ -1493,6 +1784,10 @@ var SubstitutionResolver = class {
     // xx.hocon PR (see Phase 6 #3f close-out notes).
     this.resolvingConcats = /* @__PURE__ */ new WeakSet();
   }
+  /** 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);
   }
@@ -1533,7 +1828,8 @@ var SubstitutionResolver = class {
     if (isConcat(v)) {
       this.resolvingConcats.add(v);
       try {
-        return this.resolveConcat(v.nodes, scope, v.line, v.col);
+        const concatResult = this.resolveConcat(v.nodes, scope, v.line, v.col);
+        return concatResult;
       } finally {
         this.resolvingConcats.delete(v);
       }
@@ -1578,7 +1874,7 @@ var SubstitutionResolver = class {
       }
       if (s.optional) return void 0;
       throw new ResolveError(
-        `circular substitution: ${key}`,
+        this.originPrefix() + `circular substitution: ${key}`,
         key,
         s.line,
         s.col
@@ -1608,7 +1904,7 @@ var SubstitutionResolver = class {
           }
           if (s.optional) return void 0;
           throw new ResolveError(
-            `could not resolve substitution: \${${key}}`,
+            `${this.originPrefix()}could not resolve substitution: \${${key}}`,
             key,
             s.line,
             s.col
@@ -1641,7 +1937,7 @@ var SubstitutionResolver = class {
         if (result !== void 0) this.cache.set(key, result);
         return result;
       }
-      if (s.listSuffix) {
+      if (s.listSuffix && this.opts.useSystemEnvironment !== false) {
         const result = this.resolveEnvList(s);
         if (result !== void 0) {
           this.cache.set(key, result);
@@ -1650,22 +1946,36 @@ var SubstitutionResolver = class {
         if (s.optional) return void 0;
         const envBase = s.segments.map((seg) => seg.text).join(".");
         throw new ResolveError(
-          `could not resolve substitution: \${${key}} (no environment variables ${envBase}_0, ${envBase}_1, \u2026 set)`,
+          `${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
         );
       }
-      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 (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(
-        `could not resolve substitution: \${${key}}`,
+        `${this.originPrefix()}could not resolve substitution: \${${key}}`,
         key,
         s.line,
         s.col
@@ -1710,8 +2020,16 @@ var SubstitutionResolver = class {
     return [full, bare];
   }
   resolveConcat(nodes, scope, line = 0, col = 0) {
-    const resolved = nodes.map((n) => this.resolveVal(n, scope)).filter((v) => v !== void 0);
-    if (resolved.length === 0) return { kind: "scalar", raw: "null", valueType: "null" };
+    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) {
@@ -1785,15 +2103,89 @@ var SubstitutionResolver = class {
 };
 
 // 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) || isAppend(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) && !isAppend(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 root = new StructureBuilder(opts).build(ast);
-  return new SubstitutionResolver(root, opts).resolve();
+  const tree = buildTree(ast, opts);
+  return resolveTree(tree, { ...opts, useSystemEnvironment: true, allowUnresolved: false });
 }
 
 // src/config.ts
 var Config = class _Config {
-  constructor(root) {
+  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);
@@ -1837,13 +2229,29 @@ var Config = class _Config {
   }
   getConfig(path2) {
     const v = this.lookupNode(path2);
-    if (v === void 0) throw new ConfigError(`path not found: ${path2}`, 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);
-    return new _Config(v);
+    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) throw new ConfigError(`path not found: ${path2}`, 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(hoconToJs);
@@ -1858,12 +2266,138 @@ var Config = class _Config {
     return [...this.root.fields.keys()];
   }
   withFallback(fallback) {
-    const merged = deepMergeHocon(this.root, fallback.root);
-    return new _Config(merged);
+    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
+    });
   }
   toObject() {
     return hoconToJs(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;
@@ -1875,9 +2409,40 @@ var Config = class _Config {
     }
     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) throw new ConfigError(`path not found: ${path2}`, 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;
   }
@@ -1940,28 +2505,89 @@ function hoconToJs(v) {
     case "array":
       return v.items.map(hoconToJs);
     case "object": {
-      const obj = {};
+      const obj = /* @__PURE__ */ Object.create(null);
       for (const [k, val] of v.fields) obj[k] = hoconToJs(val);
-      return obj;
+      return Object.assign({}, obj);
     }
   }
 }
-function deepMergeHocon(receiver, fallback) {
-  const merged = new Map(fallback.fields);
-  for (const [k, v] of receiver.fields) {
-    const fb = merged.get(k);
-    if (fb?.kind === "object" && v.kind === "object") {
-      merged.set(k, deepMergeHocon(v, fb));
+function resObjToKeyShape(tree) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const [k, v] of tree.fields) {
+    if (isSubst(v) || isConcat(v) || isAppend(v)) {
+      fields.set(k, { kind: "scalar", raw: "", valueType: "null" });
+    } else if (isResObj(v)) {
+      fields.set(k, resObjToKeyShape(v));
     } else {
-      merged.set(k, v);
+      fields.set(k, v);
     }
   }
-  return { kind: "object", fields: merged };
+  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" || val._kind === "append-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 n = Number(v.raw);
+          if (Number.isFinite(n)) return v.raw;
+          return 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?)`);
 }
 
 // src/parse.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
 function getEnv(opts) {
   if (opts.env !== void 0) return opts.env;
   if (typeof process !== "undefined" && process.env) return process.env;
@@ -1978,7 +2604,10 @@ function buildResolveContext(input, opts) {
     env: getEnv(opts),
     baseDir: opts.baseDir,
     readFileSync: opts.readFileSync ?? defaultReadFileSync,
-    readFile: opts.readFile
+    readFile: opts.readFile,
+    originDescription: opts.originDescription,
+    resolveFrom: opts.resolveFrom,
+    packageResolver: opts.packageResolver
   };
   return { ast, resolveOpts };
 }
@@ -1986,7 +2615,7 @@ function parse(input, opts = {}) {
   const { ast, resolveOpts } = buildResolveContext(input, opts);
   const value = resolve2(ast, resolveOpts);
   if (value.kind !== "object") throw new Error("resolved value is not an object");
-  return new Config(value);
+  return new Config(value, { resolved: true, originDescription: opts.originDescription });
 }
 function parseFile(filePath, opts = {}) {
   if (typeof process === "undefined" && !opts.readFileSync) {