@nci-gis/js-tmpl 0.0.1 → 0.1.1

package/README.md

@@ -51,7 +51,8 @@ See [Design Principles](docs/PRINCIPLES.md) - Core philosophy guiding all decisi
 ## Features
 
 - 🎯 **Dynamic File Paths** - Use `${var}` placeholders in paths and filenames
-- 🧩 **Handlebars Templates** - Full Handlebars feature set (loops, conditionals, helpers)
+- 🧩 **Handlebars Templates** - Full Handlebars feature set (loops, conditionals, partials)
+- 🛠️ **Custom Helpers** - `registerHelpers` on a scoped instance, validated and atomic
 - 📦 **Partial System** - Reusable components with root and namespaced partials
 - ⚙️ **Flexible Configuration** - CLI args > project config > defaults
 - 🌲 **BFS Tree Walking** - Async, non-blocking template discovery
@@ -78,10 +79,11 @@ js-tmpl will search for a project config file in **exactly these locations**, in
 
 Everything else must be **explicitly specified**:
 
-- ✅ **Values file** - Required via `--values` flag or `valuesFile` config
-- ✅ **Template directory** - Must be in config or defaults to `templates/`
-- ✅ **Output directory** - Must be in config or defaults to `dist/`
-- ✅ **Partials directory** - Must be in config; not loaded if omitted
+- ✅ **Values file** — Optional via `--values` flag or `valuesFile` config (VP-8)
+- ✅ **Values directory** — Optional via `--values-dir` flag or `valuesDir` config (VP-6)
+- ✅ **Template directory** — Must be in config or defaults to `templates/`
+- ✅ **Output directory** — Must be in config or defaults to `dist/`
+- ✅ **Partials directory** — Must be in config; not loaded if omitted
 
 ### Override Auto-Discovery
 
@@ -166,6 +168,27 @@ const config = resolveConfig({
 await renderDirectory(config);
 ```
 
+**With custom helpers:**
+
+```javascript
+import Handlebars from 'handlebars';
+import {
+  registerHelpers,
+  renderDirectory,
+  resolveConfig,
+} from '@nci-gis/js-tmpl';
+
+const hbs = Handlebars.create();
+registerHelpers(hbs, { upper: (s) => s.toUpperCase() });
+
+await renderDirectory(resolveConfig({ valuesFile: './values.yaml' }), hbs);
+```
+
+Helpers must be pure functions. Strict mode still applies to plain
+`{{var}}` lookups around them; see
+[Strict templates](docs/API.md#strict-templates) for what is not checked
+inside helper arguments.
+
 ### 4. Get output
 
 ```text
@@ -212,6 +235,22 @@ templates/
 → dist/production/config-my-app.yaml
 ```
 
+Use `$if{var}` / `$ifn{var}` as whole directory segments to conditionally
+include or skip files based on view data:
+
+```text
+templates/
+├── common.yaml.hbs
+├── $if{prod}/
+│   └── alerts.yaml.hbs          → written only when view.prod is truthy
+└── $ifn{prod}/
+    └── debug-panel.yaml.hbs     → written only when view.prod is falsy
+```
+
+Guards are directory-only, whole-segment, and throw loudly on missing
+variables. See [API docs](docs/API.md#path-guards--conditional-files) for
+the full semantics and rejected variants.
+
 ### Partial System
 
 Each render pass uses an isolated Handlebars instance. Directory structure maps to partial names:
@@ -242,7 +281,7 @@ Duplicate partial names throw an error. Names must be alphanumeric + underscore
 Think of js-tmpl as a function:
 
 ```text
-(input templates, data, config) → output files
+f(config, values/view, input templates) → files (output)
 ```
 
 There is no hidden state, no lifecycle, and no side effects.
@@ -256,16 +295,28 @@ js-tmpl render [options]
 
 ### Options
 
-| Option                   | Description                             | Default         |
-| ------------------------ | --------------------------------------- | --------------- |
-| `-c, --values FILE`      | Values file (YAML/JSON)                 | **Required**    |
-| `-t, --template-dir DIR` | Template directory                      | `templates`     |
-| `-o, --out DIR`          | Output directory                        | `dist`          |
-| `-p, --partials-dir DIR` | Partials directory                      | None (skipped)  |
-| `-x, --ext EXT`          | Template extension                      | `.hbs`          |
-| `--config-file FILE`     | Explicit config file                    | Auto-discovered |
-| `--env-keys KEYS`        | Comma-separated env var names to expose | None            |
-| `--env-prefix PREFIX`    | Auto-include env vars with this prefix  | None            |
+| Option                   | Description                              | Default         |
+| ------------------------ | ---------------------------------------- | --------------- |
+| `-c, --values FILE`      | Values file (`.yaml` / `.yml` / `.json`) | Optional        |
+| `--values-dir DIR`       | Value-partials root (namespaced by path) | Optional        |
+| `-t, --template-dir DIR` | Template directory                       | `templates`     |
+| `-o, --out DIR`          | Output directory                         | `dist`          |
+| `-p, --partials-dir DIR` | Partials directory                       | None (skipped)  |
+| `-x, --ext EXT`          | Template extension                       | `.hbs`          |
+| `--config-file FILE`     | Explicit config file                     | Auto-discovered |
+| `--env-keys KEYS`        | Comma-separated env var names to expose  | None            |
+| `--env-prefix PREFIX`    | Auto-include env vars with this prefix   | None            |
+| `--verbose`              | Print stack traces on error              | Off             |
+| `-h, --help`             | Show usage                               |                 |
+
+The CLI is strict: an unknown option, an option without its value, a
+repeated option, or an unexpected argument is an error. Exit codes: `0`
+success, `1` render or configuration error, `2` usage error.
+
+Both `--values` and `--values-dir` are optional (VP-8, VP-6). If neither is
+supplied, `view` is `{ env: {...} }` only. Missing `{{var}}` in a template
+throws with the template's relative path and variable name (VP-9, strict
+mode).
 
 ### Examples of Usage
 
@@ -289,12 +340,16 @@ See [docs/API.md](docs/API.md) for the complete API reference — parameters, re
 
 ## Examples
 
-See [examples/yaml-templates/](examples/yaml-templates/) for a complete working example demonstrating:
-
-- Dynamic file paths with `${env.NODE_ENV}`
-- Handlebars features (loops, conditionals)
-- Root and namespaced partials
-- Multi-format output (YAML, Markdown)
+- [examples/yaml-templates/](examples/yaml-templates/) — complete walkthrough:
+  dynamic paths with `${env.NODE_ENV}`, Handlebars features (loops,
+  conditionals), root and namespaced partials, multi-format output.
+- [examples/path-guards/](examples/path-guards/) — conditional files via
+  `$if{var}` / `$ifn{var}` whole-segment path guards.
+- [examples/value-partials/](examples/value-partials/) — composing `view`
+  from multiple structured files via `--values-dir` (directory-as-namespace,
+  no merge, `@`-flatten escape).
+- [examples/helpers/](examples/helpers/) — registering pure custom helpers on
+  a scoped Handlebars instance with `registerHelpers`.
 
 ## Testing
 
@@ -337,7 +392,7 @@ For security concerns, see [SECURITY.md](SECURITY.md).
 
 ## License
 
-MIT © pasxd245
+See [LICENSE](LICENSE).
 
 ## Learn More
 
@@ -354,3 +409,7 @@ MIT © pasxd245
 - [Examples](examples/) - Working examples and templates
 - [Issue Tracker](https://github.com/nci-gis/js-tmpl/issues) - Report bugs or request features
 - [NPM Package](https://www.npmjs.com/package/@nci-gis/js-tmpl) - Package registry
+
+## Transparency
+
+AI-assisted development (e.g., Claude Code, Copilot) was used for scaffolding and iteration.

package/bin/js-tmpl.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+// Installed CLI entry. A Node file, not a shell wrapper: npm links it from
+// node_modules/.bin on every OS, and imports resolve from this file's real
+// location, not from the symlink.
+import { run } from '../src/cli/main.js';
+
+process.exitCode = await run(process.argv.slice(2));

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@nci-gis/js-tmpl",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "description": "The pure JavaScript templating engine that uses handlebars.",
   "type": "module",
   "bin": {
-    "js-tmpl": "bin/js-tmpl"
+    "js-tmpl": "bin/js-tmpl.js"
   },
   "exports": {
     ".": {
@@ -13,11 +13,15 @@
   },
   "scripts": {
     "prepare": "husky",
-    "test": "node --test $(find tests -name '*.test.js')",
-    "test:watch": "node --test --watch $(find tests -name '*.test.js')",
-    "test:coverage": "node --experimental-test-coverage --test $(find tests -name '*.test.js')",
-    "format": "prettier --write src/ tests/",
-    "format:check": "prettier --check src/ tests/",
+    "test": "node --test",
+    "test:watch": "node --test --watch",
+    "test:coverage": "node --test --experimental-test-coverage --test-coverage-exclude=\"tests/**\" --test-coverage-exclude=\"examples/**\" --test-coverage-lines=99 --test-coverage-branches=99 --test-coverage-functions=99",
+    "format": "pnpm format:code && pnpm format:md",
+    "format:check": "pnpm format:code:check && pnpm format:md:check",
+    "format:code": "prettier --write src/ tests/",
+    "format:code:check": "prettier --check src/ tests/",
+    "format:md": "prettier --write \"*.md\" \"docs/**/*.md\" \"tests/**/*.md\" \"examples/**/*.md\"",
+    "format:md:check": "prettier --check \"*.md\" \"docs/**/*.md\" \"tests/**/*.md\" \"examples/**/*.md\"",
     "lint": "eslint src/ tests/",
     "lint:fix": "eslint src/ tests/ --fix",
     "build": "echo 'No build step required for pure JS library'",
@@ -27,7 +31,10 @@
     "tool": "node src/cli/main.js",
     "docs:check-links": "remark --frail --quiet *.md docs/*.md tests/README.md examples/**/*.md",
     "docs:check-exports": "node scripts/check-doc-exports.js",
-    "docs:check": "pnpm docs:check-links && pnpm docs:check-exports"
+    "docs:check": "pnpm docs:check-links && pnpm docs:check-exports",
+    "examples:update": "node scripts/update-golden.js",
+    "pack:check": "node scripts/check-pack.js",
+    "verify": "pnpm lint && pnpm format:check && pnpm docs:check && pnpm pack:check && pnpm test:coverage"
   },
   "keywords": [
     "js",
@@ -57,11 +64,12 @@
   },
   "packageManager": "pnpm@10.22.0",
   "dependencies": {
-    "config": "^4.1.1",
     "handlebars": "^4.7.8",
     "js-yaml": "^4.1.1"
   },
   "devDependencies": {
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-conventional": "^20.5.0",
     "@eslint/js": "^9.39.2",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.5.2",

package/src/cli/args.js

@@ -1,69 +1,146 @@
+import { parseArgs as parseNodeArgs } from 'node:util';
+
 /**
- * Parse CLI arguments.
- *
- * @param {string[]} args
- * @returns {import('../types.js').CliArgs}
+ * The command line was malformed: unknown option, missing value, stray
+ * argument. The CLI exits with code 2 for these, distinct from render or
+ * config failures (code 1).
  */
-export function parseArgs(args) {
-  /** @type {import('../types.js').CliArgs} */
-  const opts = { command: 'render' };
-
-  let i = 0;
-  while (i < args.length) {
-    const a = args[i];
+export class UsageError extends Error {
+  /** @param {string} message */
+  constructor(message) {
+    super(message);
+    this.name = 'UsageError';
+  }
+}
 
-    switch (a) {
-      case '-h':
-      case '--help':
-        opts.command = 'help';
-        break;
+/** Option name → CliArgs field. Short aliases live in OPTIONS. */
+const FIELDS = {
+  'template-dir': 'templateDir',
+  values: 'valuesFile',
+  'values-dir': 'valuesDir',
+  out: 'outDir',
+  'partials-dir': 'partialsDir',
+  'config-file': 'configFile',
+  ext: 'extname',
+  'env-prefix': 'envPrefix',
+};
 
-      case 'render':
-        opts.command = 'render';
-        break;
+/** @type {import('node:util').ParseArgsConfig['options']} */
+const OPTIONS = {
+  help: { type: 'boolean', short: 'h' },
+  verbose: { type: 'boolean' },
+  'template-dir': { type: 'string', short: 't' },
+  values: { type: 'string', short: 'c' },
+  'values-dir': { type: 'string' },
+  out: { type: 'string', short: 'o' },
+  'partials-dir': { type: 'string', short: 'p' },
+  'config-file': { type: 'string' },
+  ext: { type: 'string', short: 'x' },
+  'env-keys': { type: 'string' },
+  'env-prefix': { type: 'string' },
+};
 
-      case '-t':
-      case '--template-dir':
-        opts.templateDir = args[++i];
-        break;
+const COMMANDS = new Set(['render']);
 
-      case '-c':
-      case '--values':
-        opts.valuesFile = args[++i];
-        break;
+/**
+ * Run node:util parseArgs, turning its errors into UsageError with the
+ * first sentence of Node's message (the rest is generic advice). An option
+ * followed by another option (`-o --values x`) is reported as missing its
+ * value rather than taking `--values` as the output dir.
+ *
+ * @param {string[]} args
+ */
+function tokenize(args) {
+  try {
+    return parseNodeArgs({
+      args,
+      options: OPTIONS,
+      strict: true,
+      allowPositionals: true,
+      tokens: true,
+    });
+  } catch (error) {
+    const err = /** @type {Error & { code?: string }} */ (error);
+    if (err.code?.startsWith('ERR_PARSE_ARGS_')) {
+      const first = err.message.split(/\.(?:\s|$)/)[0];
+      const ambiguous = first.match(/^Option '([^']+)' argument is ambiguous/);
+      throw new UsageError(
+        ambiguous ? `Option '${ambiguous[1]}' is missing its value` : first,
+      );
+    }
+    throw err;
+  }
+}
 
-      case '-o':
-      case '--out':
-        opts.outDir = args[++i];
-        break;
+/**
+ * Throw if any option appears more than once (no silent last-wins).
+ *
+ * @param {Array<{ kind: string, name?: string, rawName?: string }>} tokens
+ */
+function assertNoRepeats(tokens) {
+  /** @type {Map<string, string>} */
+  const seen = new Map();
+  for (const t of tokens) {
+    if (t.kind !== 'option' || !t.name) {
+      continue;
+    }
+    if (seen.has(t.name)) {
+      throw new UsageError(
+        `Option '--${t.name}' given more than once (${seen.get(t.name)}, ${t.rawName})`,
+      );
+    }
+    seen.set(t.name, t.rawName ?? `--${t.name}`);
+  }
+}
 
-      case '-p':
-      case '--partials-dir':
-        opts.partialsDir = args[++i];
-        break;
+/**
+ * Parse CLI arguments (without the node binary and script path).
+ *
+ * Strict: unknown options, options missing their value, repeated options,
+ * and positional arguments other than one `render` command throw
+ * `UsageError`. Only options actually given appear in the result, so unset
+ * options never override config-file or default values.
+ *
+ * @param {string[]} args - e.g. `process.argv.slice(2)`
+ * @returns {import('../types.js').CliArgs}
+ * @throws {UsageError}
+ */
+export function parseArgs(args) {
+  const { values, positionals, tokens } = tokenize(args);
+  assertNoRepeats(/** @type {any[]} */ (tokens));
 
-      case '--config-file':
-        opts.configFile = args[++i];
-        break;
+  const [command = 'render', ...extra] = positionals;
+  if (!COMMANDS.has(command)) {
+    throw new UsageError(`Unknown command '${command}'`);
+  }
+  if (extra.length > 0) {
+    throw new UsageError(`Unexpected argument '${extra[0]}'`);
+  }
 
-      case '-x':
-      case '--ext':
-        opts.extname = args[++i];
-        break;
+  /** @type {import('../types.js').CliArgs} */
+  const opts = { command: values.help ? 'help' : command };
+  if (values.verbose) {
+    opts.verbose = true;
+  }
 
-      case '--env-keys':
-        opts.envKeys = args[++i]
-          .split(',')
-          .map((s) => s.trim())
-          .filter(Boolean);
-        break;
+  for (const [option, field] of Object.entries(FIELDS)) {
+    const value = values[option];
+    if (typeof value === 'string') {
+      /** @type {Record<string, unknown>} */ (opts)[field] = value;
+    }
+  }
 
-      case '--env-prefix':
-        opts.envPrefix = args[++i];
-        break;
+  if (typeof values['env-keys'] === 'string') {
+    const keys = values['env-keys']
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean);
+    if (keys.length === 0) {
+      throw new UsageError(
+        "Option '--env-keys' needs at least one variable name",
+      );
     }
-    // next argument:
-    i++;
+    opts.envKeys = keys;
   }
 
   return opts;

package/src/cli/main.js

@@ -2,40 +2,61 @@
 
 import { resolveConfig } from '../config/resolver.js';
 import { renderDirectory } from '../engine/renderDirectory.js';
-import { parseArgs } from './args.js';
+import { parseArgs, UsageError } from './args.js';
 import { USAGE } from './usage.js';
 
-/** @returns {Promise<void>} */
-export async function main() {
-  const cli = parseArgs(process.argv);
+/**
+ * Parse arguments and run the command. Throws on any failure; `run` turns
+ * that into output and an exit code.
+ *
+ * @param {string[]} argv - Arguments without the node binary and script path
+ * @returns {Promise<void>}
+ */
+export async function main(argv) {
+  const cli = parseArgs(argv);
 
   if (cli.command === 'help') {
     console.log(USAGE);
     return;
   }
 
-  if (cli.command !== 'render') {
-    console.error('Unknown command:', cli.command);
-    process.exit(1);
-  }
-
   const cfg = resolveConfig(cli);
-
   await renderDirectory(cfg);
-
   console.log('✔ js-tmpl completed.');
 }
 
-// Execute main function if this file is run directly
+/**
+ * CLI error boundary. Prints `js-tmpl: <message>` (plus the stack with
+ * `--verbose`) and returns the exit code: 0 ok, 1 render/config error,
+ * 2 usage error.
+ *
+ * @param {string[]} argv - Arguments without the node binary and script path
+ * @returns {Promise<number>}
+ */
+export async function run(argv) {
+  try {
+    await main(argv);
+    return 0;
+  } catch (error) {
+    const err = /** @type {Error} */ (error);
+    console.error(`js-tmpl: ${err.message}`);
+    if (err instanceof UsageError) {
+      console.error("Run 'js-tmpl --help' for usage.");
+      return 2;
+    }
+    if (argv.includes('--verbose')) {
+      console.error(err.stack);
+    }
+    return 1;
+  }
+}
+
+// Direct execution (`node src/cli/main.js …`). The installed CLI enters
+// through bin/js-tmpl.js instead, which calls `run` itself.
 const isDirectRun =
   process.argv[1] &&
   import.meta.url.endsWith(process.argv[1].replaceAll('\\', '/'));
 
 if (isDirectRun) {
-  try {
-    await main();
-  } catch (error) {
-    console.error('Error:', error);
-    process.exit(1);
-  }
+  process.exitCode = await run(process.argv.slice(2));
 }

package/src/cli/usage.js

@@ -6,11 +6,18 @@ Commands:
 
 Options:
   -t, --template-dir <dir>   Template directory (default: templates)
-  -c, --values <file>        Values file (YAML or JSON) [required]
+  -c, --values <file>        Values file (.yaml / .yml / .json) — optional
+      --values-dir <dir>     Value-partials root, namespaced into view by path
   -o, --out <dir>            Output directory (default: dist)
   -p, --partials-dir <dir>   Partials directory
   -x, --ext <ext>            Template extension (default: .hbs)
       --config-file <file>   Project config file
       --env-keys <keys>      Comma-separated env var names to expose (default: none)
       --env-prefix <prefix>  Auto-include env vars with this prefix (e.g. JS_TMPL_)
-  -h, --help                 Show this help message`;
+      --verbose              Print stack traces on error
+  -h, --help                 Show this help message
+
+Exit codes:
+  0  success
+  1  render or configuration error
+  2  usage error (unknown option, missing value, unexpected argument)`;

package/src/config/resolver.js

@@ -3,71 +3,62 @@ import process from 'node:process';
 
 import { DEFAULTS } from './defaults.js';
 import { loadProjectConfig, loadYamlOrJson } from './loader.js';
+import { scanValuePartials } from './valuePartials.js';
 import { buildView, pickEnv } from './view.js';
 
 /**
- * Resolve valuesFile path based on valuesDir
- * @param {string} valuesFile - The values file name or path
- * @param {string} valuesDir - Values directory (may be empty string)
- * @param {string} cwd - Current working directory
- * @returns {string} Absolute path to values file
+ * C-1 — throw if the resolved `valuesFile` sits inside the resolved
+ * `valuesDir`. A file loaded both as root and as a value partial would
+ * produce ambiguous collisions.
+ *
+ * @param {string} valuesFileAbs
+ * @param {string} valuesDirAbs
  */
-function resolveValuesFilePath(valuesFile, valuesDir, cwd) {
-  // If absolute, use as-is
-  if (path.isAbsolute(valuesFile)) {
-    return valuesFile;
-  }
-
-  // If valuesDir is set (truthy), use it as base
-  if (valuesDir) {
-    const absoluteValuesDir = path.isAbsolute(valuesDir)
-      ? valuesDir
-      : path.join(cwd, valuesDir);
-    return path.join(absoluteValuesDir, valuesFile);
+function assertValuesFileNotInside(valuesFileAbs, valuesDirAbs) {
+  const rel = path.relative(valuesDirAbs, valuesFileAbs);
+  const inside = rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+  if (inside) {
+    throw new Error(
+      `valuesFile '${valuesFileAbs}' is inside valuesDir '${valuesDirAbs}'.\n` +
+        `Move the file out, or drop valuesDir.`,
+    );
   }
-
-  // Otherwise, resolve from cwd
-  return path.join(cwd, valuesFile);
 }
 
 /**
- * Resolve final config using:
- * defaults < projectConfig < cliArgs
+ * Resolve final config using: defaults < projectConfig < cliArgs.
+ *
+ * Value sources (all optional per VP-5, VP-6, VP-8):
+ * - `valuesFile` loaded into top-level view keys.
+ * - `valuesDir` scanned via `scanValuePartials` into a namespaced tree.
+ * - Allowlisted env vars under `view.env.*`.
  *
- * @param {import('../types.js').CliArgs} cli - CLI arguments
- * @param {string} [cwd] - Current working directory
- * @returns {import('../types.js').TemplateConfig} - Resolved configuration
+ * Collision rules C-1, C-2, C-3 apply and surface as hard errors.
+ *
+ * @param {import('../types.js').CliArgs} cli
+ * @param {string} [cwd]
+ * @returns {import('../types.js').TemplateConfig}
  */
 export function resolveConfig(cli, cwd = process.cwd()) {
   const projectConfig = loadProjectConfig(cwd, cli.configFile);
-
-  const mergedConfig = {
-    ...DEFAULTS,
-    ...projectConfig,
-    ...cli,
-  };
+  const mergedConfig = { ...DEFAULTS, ...projectConfig, ...cli };
 
   /** @param {string} p */
   const abs = (p) => (path.isAbsolute(p) ? p : path.join(cwd, p));
 
-  // Validate valuesFile is provided
-  if (!mergedConfig.valuesFile) {
-    throw new Error(
-      'Missing required configuration: valuesFile\n' +
-        'Provide via:\n' +
-        '  - CLI: --values path/to/values.yaml\n' +
-        '  - Config: valuesFile: "path/to/values.yaml" in js-tmpl.config.yaml',
-    );
-  }
+  const valuesFileAbs = mergedConfig.valuesFile
+    ? abs(mergedConfig.valuesFile)
+    : '';
+  const valuesDirAbs = mergedConfig.valuesDir
+    ? abs(mergedConfig.valuesDir)
+    : '';
 
-  // Resolve path - simple logic based on valuesDir presence
-  const valuesFilePath = resolveValuesFilePath(
-    mergedConfig.valuesFile,
-    mergedConfig.valuesDir,
-    cwd,
-  );
+  if (valuesFileAbs && valuesDirAbs) {
+    assertValuesFileNotInside(valuesFileAbs, valuesDirAbs);
+  }
 
-  const values = loadYamlOrJson(valuesFilePath);
+  const rootValues = valuesFileAbs ? loadYamlOrJson(valuesFileAbs) : {};
+  const partials = valuesDirAbs ? scanValuePartials(valuesDirAbs) : {};
 
   const hasEnvConfig = mergedConfig.envKeys?.length || mergedConfig.envPrefix;
   const env = hasEnvConfig
@@ -82,6 +73,12 @@ export function resolveConfig(cli, cwd = process.cwd()) {
     partialsDir: mergedConfig.partialsDir ? abs(mergedConfig.partialsDir) : '',
     outDir: abs(mergedConfig.outDir),
     extname: mergedConfig.extname,
-    view: buildView(values, env),
+    view: buildView({
+      rootValues,
+      partials,
+      env,
+      valuesFile: valuesFileAbs || '<unset>',
+      valuesDir: valuesDirAbs || '<unset>',
+    }),
   };
 }