@intentius/chant 0.124.12 → 0.124.14

package/dist/discovery/sandbox/bundle.js

@@ -0,0 +1,214 @@
+import * as esbuild from "esbuild";
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve as resolvePath } from "node:path";
+/**
+ * chant #1045 Phase 2 — bundles the generated sandbox driver (`./driver.ts`)
+ * into one self-contained ESM file with esbuild, so the sandboxed child never
+ * needs to resolve a module from disk at runtime (see `./driver.ts`'s doc for
+ * why that's what lets the permission allowlist stay this narrow).
+ *
+ * A fresh temp directory per call — not a shared cache directory — keeps
+ * concurrent builds (nested stacks, parallel test workers) from racing on the
+ * same output path; callers are responsible for cleaning it up (`./run.ts`
+ * does, in a `finally`) once the child has reported back.
+ */
+const HERE = import.meta.dirname;
+const require = createRequire(import.meta.url);
+/**
+ * Packages that must NOT be bundled — see {@link resolveExternalPackages}'s
+ * doc for why. Every lexicon that ships a lint rule doing AST-based analysis
+ * (`aws`, `azure`, `fly`, `gcp`, `github`, `gitlab`, `helm`, `k8s` all do)
+ * imports `typescript` at the top of that rule module, and lexicon plugin
+ * objects re-export their lint rules eagerly — so bundling ANY run-fallback
+ * file that imports a lexicon package pulls `typescript` in transitively,
+ * every time, not just for the rare file that uses the compiler itself.
+ *
+ * `@cdktn/hcl2json` is here for the same reason and by a longer road. It is
+ * an OPTIONAL dependency — `../../terraform/hcl2json.ts` reaches it through
+ * `await import(...)` and turns a missing module into an actionable "npm
+ * install -D @cdktn/hcl2json" — but esbuild follows a dynamic import as
+ * eagerly as a static one, and the package ships a Go `wasm_exec` shim whose
+ * `performance` reference does not resolve under `platform: "node"`. So a
+ * bundle that merely *reaches* the carve commands fails outright. Reaching
+ * them is easy: the fountain lexicon's ACP server dynamically imports
+ * `cli/main` to resolve a prompt against chant's verb registry (chant #2125),
+ * so every project that imports `@intentius/chant-lexicon-fountain` and needs
+ * the run fallback — a `Steward` declaration does, since a composite call
+ * cannot fold — pulled the whole CLI, and carve with it, into its sandbox
+ * bundle (chant #2129).
+ */
+const EXTERNAL_PACKAGES = ["typescript", "@cdktn/hcl2json"];
+/**
+ * Resolve each of {@link EXTERNAL_PACKAGES} to its real, absolute path on
+ * disk (from THIS file's own location — the same package.json dependency
+ * chant's own `fold-import.ts` already resolves "typescript" through) and
+ * return an esbuild plugin that rewrites any import of that bare specifier
+ * to the resolved absolute path, marked external.
+ *
+ * Why external at all: `typescript` is itself a large, over-eager CJS
+ * package — its own internal `getNodeSystem()`-style helpers call
+ * `require("fs")`/`require("path")` from deep inside factory functions, not
+ * from top-level imports esbuild can safely rewrite. Bundled into ESM
+ * output, that nested `require` has no real binding and esbuild's shim
+ * throws `Dynamic require of "fs" is not supported` — a build that just
+ * transitively imports `typescript` never even gets to execute the run-
+ * fallback file it was meant for. Left external and resolved to an absolute
+ * path, Node loads the REAL `typescript` package directly (no bare-specifier
+ * `node_modules` walk needed, so no broader `--allow-fs-read` grant beyond
+ * that one resolved path — see `./run.ts`), with its own native `require`
+ * intact — no interop shim, no problem.
+ *
+ * `typescript` is trusted, chant-shipped infrastructure (a dependency of
+ * chant itself and every lexicon that lints), never something project
+ * source controls the content of, so resolving and exposing it this way
+ * doesn't weaken the boundary around untrusted project code.
+ */
+/**
+ * chant #1020 hang fix — process-wide memo for resolving {@link
+ * EXTERNAL_PACKAGES} from {@link HERE}. Both are fixed constants (this
+ * file's own location, and a hardcoded package list) — the answer can never
+ * change for the lifetime of the process, so caching it is exactly as safe
+ * as Node's own assumption that a running process's `node_modules` doesn't
+ * shift under it. `require.resolve(name, { paths: [HERE] })` is ordinarily
+ * cheap, but profiling traced it to the same pathological slowness (upwards
+ * of a minute) as `../fold-import.ts`'s `resolveModulePath` — see that
+ * file's `bareSpecifierPathCache` doc for the full mechanism: this is the
+ * SAME underlying cost (`createRequire`/`require.resolve`'s bare-specifier
+ * branch, first call inside a session started right after vitest's
+ * `vi.resetModules()`), just reached via `bundleDriver()` (called once per
+ * `runFallbackFilesSandboxed()`) instead of a cross-file fold resolution.
+ *
+ * Parked on `globalThis`, not a plain module-level `const`: unlike
+ * `fold-import.ts` (reached only via a STATIC import chain from the test
+ * file's own top-level import, so vite-node never re-evaluates it),
+ * `./bundle.ts` is reached only through `./run.ts`'s dynamic
+ * `await import("./sandbox/run")` (deliberately dynamic — see that file's
+ * own doc on why). `vi.resetModules()` DOES re-evaluate a module reached
+ * only dynamically, which would re-run this file's whole top level and
+ * silently replace a plain module-level cache with a fresh, empty `Map` on
+ * every retry — measured to happen intermittently (which call site hits the
+ * slow, uncached path first varies run to run), reproducing the exact same
+ * multi-minute stall this fix exists to remove. A `globalThis` slot is
+ * outside any module's own scope, so it survives being re-evaluated.
+ */
+function getExternalPackagePathCache() {
+    const g = globalThis;
+    return (g.__chantExternalPackagePathCache ?? (g.__chantExternalPackagePathCache = new Map()));
+}
+/**
+ * chant #1020 hang fix — best-effort fast path mirroring
+ * `../fold-import.ts`'s `fastResolveBareSpecifier` (see its own doc for the
+ * full mechanism and why this is faster than `require.resolve` at all):
+ * walks `node_modules` from `fromDir` with plain `existsSync`/`readFileSync`
+ * and reads `package.json`'s "main" field by hand (`typescript` ships no
+ * "exports" field, just "main" — verified), never throwing. Returns
+ * `undefined` for anything it doesn't confidently recognize, so the caller
+ * falls back to the slow-but-authoritative `require.resolve`.
+ */
+function fastResolvePackage(specifier, fromDir) {
+    let dir = fromDir;
+    for (;;) {
+        const packageDir = join(dir, "node_modules", specifier);
+        if (existsSync(packageDir)) {
+            const pkgJsonPath = join(packageDir, "package.json");
+            if (!existsSync(pkgJsonPath))
+                return undefined;
+            let pkg;
+            try {
+                pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+            }
+            catch {
+                return undefined;
+            }
+            if (typeof pkg !== "object" || pkg === null || pkg.exports !== undefined) {
+                return undefined; // has an "exports" field — not the simple shape this fast path handles
+            }
+            const main = pkg.main;
+            const entry = typeof main === "string" ? main : "index.js";
+            const resolved = resolvePath(packageDir, entry);
+            if (!existsSync(resolved) || !statSync(resolved).isFile())
+                return undefined;
+            try {
+                return realpathSync(resolved);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function externalTrustedPackagesPlugin() {
+    const readPaths = [];
+    const resolved = new Map();
+    const pathCache = getExternalPackagePathCache();
+    for (const name of EXTERNAL_PACKAGES) {
+        try {
+            let path = pathCache.get(name);
+            if (path === undefined && !pathCache.has(name)) {
+                // chant #1020 hang fix — try the same fast, plain-fs node_modules
+                // walk `../fold-import.ts`'s `fastResolveBareSpecifier` uses before
+                // falling back to `require.resolve`'s pathologically-slow-when-cold
+                // path (see this file's own `getExternalPackagePathCache` doc).
+                path = fastResolvePackage(name, HERE) ?? require.resolve(name, { paths: [HERE] });
+                pathCache.set(name, path);
+            }
+            if (path === undefined)
+                continue; // cached miss — see the catch below
+            resolved.set(name, path);
+            readPaths.push(dirname(path));
+        }
+        catch {
+            pathCache.set(name, undefined);
+            // Not installed/resolvable from here — nothing to externalize; a run-
+            // fallback file that imports it will simply fail to resolve inside the
+            // sandbox, same as any other genuinely missing dependency would.
+        }
+    }
+    const plugin = {
+        name: "chant-sandbox-external-trusted-packages",
+        setup(build) {
+            for (const [name, path] of resolved) {
+                const filter = new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`);
+                build.onResolve({ filter }, () => ({ path, external: true }));
+            }
+        },
+    };
+    return { plugin, readPaths };
+}
+/**
+ * Bundle `driverSource` (see {@link import("./driver.js").generateDriverSource})
+ * into a single self-contained ESM file.
+ */
+export async function bundleDriver(driverSource) {
+    const bundleDir = realpathSync(mkdtempSync(join(tmpdir(), "chant-sandbox-")));
+    const entryPath = join(bundleDir, "driver.mts");
+    writeFileSync(entryPath, driverSource, "utf-8");
+    const outfile = join(bundleDir, "child.mjs");
+    const { plugin, readPaths } = externalTrustedPackagesPlugin();
+    const start = performance.now();
+    try {
+        await esbuild.build({
+            entryPoints: [entryPath],
+            outfile,
+            bundle: true,
+            platform: "node",
+            format: "esm",
+            absWorkingDir: bundleDir,
+            logLevel: "silent",
+            plugins: [plugin],
+        });
+    }
+    catch (err) {
+        rmSync(bundleDir, { recursive: true, force: true });
+        throw err;
+    }
+    const durationMs = performance.now() - start;
+    const bytes = statSync(outfile).size;
+    return { bundlePath: outfile, bundleDir, externalReadPaths: readPaths, durationMs, bytes };
+}

package/dist/discovery/sandbox/child-errors.js

@@ -0,0 +1,26 @@
+import { DiscoveryError } from "../../errors.js";
+function isPermissionDenied(err) {
+    return typeof err === "object" && err !== null && err.code === "ERR_ACCESS_DENIED";
+}
+/**
+ * Classify one error raised while executing run-fallback project source (or
+ * chant's own collect/resolve/encode step) inside the sandboxed child.
+ *
+ * @param file - The project source file being executed when `err` was
+ *   thrown, or `""` for an error not attributable to one specific file (e.g.
+ *   `collectEntities`/`resolveAttrRefs` over the whole batch).
+ * @param fallbackType - The {@link DiscoveryErrorType} to use when `err`
+ *   isn't a permission denial — mirrors how `discover()` itself types a
+ *   plain import failure `"import"` vs. a collection/resolution failure
+ *   `"resolution"`.
+ */
+export function classifyChildError(file, err, fallbackType = "import") {
+    if (isPermissionDenied(err)) {
+        const operation = typeof err.permission === "string" ? err.permission : "an unrecognized sandboxed operation";
+        const resource = typeof err.resource === "string" ? ` (${err.resource})` : "";
+        const where = file ? `"${file}"` : "sandboxed run-fallback code";
+        return new DiscoveryError(file, `sandbox denied ${operation}${resource}: ${where} attempted an operation outside the sandbox's allowlist`, "permission");
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return new DiscoveryError(file, message, fallbackType);
+}

package/dist/discovery/sandbox/config-run.js

@@ -0,0 +1,100 @@
+import { realpathSync, rmSync } from "node:fs";
+import { resolve } from "node:path";
+import { bundleDriver } from "./bundle.js";
+import { generateConfigDriverSource } from "./driver.js";
+import { formatConfigWireOffenders } from "./config-wire.js";
+import { forkSandboxed } from "./fork.js";
+import { ENV_VAR } from "../../env.js";
+/**
+ * chant #1113 — evaluates a project's `chant.config.ts` inside the same
+ * sandboxed child `--sandbox` already uses for run-fallback source, and brings
+ * back plain JSON.
+ *
+ * This closes the residual chant #1093 documented and #1113 filed: `loadConfig`
+ * imported the project's own `chant.config.ts` into the CLI process, so a
+ * hostile repo's config executed with full CLI trust even under `--sandbox`.
+ * The config is project-authored code like any other file in the repo; the
+ * only reason it was ever treated differently is that the CLI has to read it
+ * before it knows anything else about the project.
+ *
+ * Deliberately the same machinery, not a parallel one:
+ *  - `./bundle.ts` bundles the generated driver (`./driver.ts`'s
+ *    `generateConfigDriverSource`) with esbuild, so the child needs no runtime
+ *    module resolution and no TypeScript loader.
+ *  - `./fork.ts` spawns it with the identical `--permission` profile
+ *    `runFallbackFilesSandboxed` uses — one function, so the two cannot drift.
+ *  - `./child-errors.ts` classifies whatever it throws, so a permission denial
+ *    names the config file instead of leaking `ERR_ACCESS_DENIED`.
+ *
+ * The one deliberate difference from the run-fallback child is `CHANT_ENV`.
+ * `../../cli/main.ts` sets it from `--env` *before* loading the config,
+ * specifically because a config may branch on the environment; dropping it
+ * would silently produce a different configuration under `--sandbox` than
+ * without. It is a value the user typed on the command line, not an ambient
+ * secret, so forwarding exactly that one key — and nothing else from
+ * `process.env` — keeps the scrub meaningful while keeping `--env` honest.
+ */
+/** How long to wait for the config child. A config is one small module; anything approaching this is hung, not slow. */
+const CONFIG_CHILD_TIMEOUT_MS = 60000;
+function isConfigChildResponse(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.kind === "chant-config" &&
+        typeof value.ok === "boolean");
+}
+/**
+ * Evaluate `configPath` in a sandboxed child and return its configuration as
+ * plain data.
+ *
+ * Throws — rather than degrading to an in-process import or to defaults — when
+ * the config cannot be evaluated inside the boundary or cannot cross it as
+ * JSON. Under `--sandbox` a config that "almost" loaded is not a safe thing to
+ * proceed with, and quietly falling back would give away the property the flag
+ * exists to provide.
+ *
+ * @param configPath - Absolute path to the project's `chant.config.ts`.
+ * @param projectRoot - Directory the child is granted `--allow-fs-read` for
+ *   (the config's own project root, i.e. `findProjectConfig`'s `dir`).
+ */
+export async function evaluateConfigSandboxed(configPath, projectRoot) {
+    const driverSource = generateConfigDriverSource(configPath);
+    const { bundlePath, bundleDir, externalReadPaths, durationMs, bytes } = await bundleDriver(driverSource);
+    try {
+        let projectRealpath;
+        try {
+            projectRealpath = realpathSync(resolve(projectRoot));
+        }
+        catch {
+            projectRealpath = resolve(projectRoot);
+        }
+        const env = { PATH: process.env.PATH ?? "" };
+        // See the module doc: the one forwarded variable, and only when set.
+        const activeEnv = process.env[ENV_VAR];
+        if (activeEnv)
+            env[ENV_VAR] = activeEnv;
+        const response = await forkSandboxed({
+            bundlePath,
+            bundleDir,
+            projectRealpath,
+            externalReadPaths,
+            env,
+            timeoutMs: CONFIG_CHILD_TIMEOUT_MS,
+            label: `sandboxed evaluation of ${configPath}`,
+            // chant #1148 — the config's own console.log/error no longer goes
+            // nowhere; see `./fork.ts`'s `outputPrefix` doc.
+            outputPrefix: "[sandbox:config]",
+        }, isConfigChildResponse);
+        if (!response.ok) {
+            if (response.offenders && response.offenders.length > 0) {
+                throw new Error(formatConfigWireOffenders(configPath, response.offenders));
+            }
+            throw new Error(response.error?.message
+                ? `Failed to evaluate ${configPath} inside the --sandbox boundary: ${response.error.message}`
+                : `Failed to evaluate ${configPath} inside the --sandbox boundary`);
+        }
+        return { config: response.config ?? {}, bundleMs: durationMs, bundleBytes: bytes };
+    }
+    finally {
+        rmSync(bundleDir, { recursive: true, force: true });
+    }
+}

package/dist/discovery/sandbox/config-wire.js

@@ -0,0 +1,183 @@
+/**
+ * chant #1113 — what a `chant.config.ts` may contain if it is to be evaluated
+ * inside the sandbox boundary and handed back to the CLI as data.
+ *
+ * Under `--sandbox` the config file is evaluated in a child process (see
+ * `./config-run.ts`), so the only thing that can come back is what survives a
+ * process boundary: JSON. Node's IPC channel serializes with `JSON.stringify`
+ * by default, and `JSON.stringify` is *lossy without complaining* — a function
+ * property vanishes, a `Date` becomes a string, a `Map` becomes `{}`, `NaN`
+ * becomes `null`. Silently handing the CLI a config that differs from the one
+ * the project wrote is the worst available outcome for a security feature, so
+ * this module walks the value FIRST and reports every offending key path.
+ * `./config-run.ts` turns a non-empty report into a build error that names the
+ * keys; nothing is ever dropped quietly.
+ *
+ * This module is bundled INTO the generated config driver (`./driver.ts`'s
+ * `generateConfigDriverSource`) and runs inside the sandboxed child, next to
+ * the project code it is inspecting — so it must not import anything, and must
+ * not touch the filesystem, the environment or the process.
+ *
+ * chant #1131 reuses the same walk for the OTHER direction: a `lint.policies`
+ * check runs inside a sandboxed child and its `PostSynthDiagnostic[]` has to
+ * come back as data (`./policy-wire.ts`). That is the same "JSON is lossy
+ * without complaining" problem with a different root value, so the walk is
+ * exported as {@link scanValueWireSafety} rather than copied.
+ *
+ * ## What `ChantConfig` legally holds
+ *
+ * Every field of `ChantConfig` (`../../config.ts`) is JSON data: string arrays
+ * (`lexicons`, `capabilities`), strings (`sourceDir`), an array of strings or
+ * plain `{ name, endpoint }` objects (`environments`, #1166), nested plain
+ * objects of strings/booleans (`ownership`, `build`, `release`, `sbom`,
+ * `signing`, `vulnPolicy`), arrays of plain objects (`stacks`), and records of
+ * plain objects (`buildParams`). `lint` is a `LintConfig`, whose rule values
+ * are a severity string or a `[severity, options]` tuple, and whose `plugins`
+ * / `policies` are file *paths* — chant loads those modules itself, they are
+ * not functions embedded in the config. So the declared type admits nothing
+ * that fails the check below.
+ *
+ * The one way to get there is `ChantConfigSchema`'s `.passthrough()`, which
+ * accepts unknown extra keys of any type (that is how a lexicon extends the
+ * config — a lexicon's own namespace key, itself pure data). A project that
+ * parks a function under such a key gets a clear
+ * error naming it, rather than a config that silently lost it.
+ *
+ * ## The one accepted lossy case: `undefined` object properties
+ *
+ * `{ sourceDir: undefined }` and `{}` are indistinguishable to every reader of
+ * `ChantConfig` — each field is optional and every resolver tests
+ * `config.x === undefined` / `?.` — so an `undefined`-valued property is
+ * dropped rather than rejected, exactly as omitting the key would be. An
+ * `undefined` inside an ARRAY is a different story (`JSON.stringify` rewrites
+ * it to `null`, changing the element), and is reported.
+ */
+/** Deepest nesting `scanConfigWireSafety` will walk before reporting the path as too deep (also the cycle backstop for exotic self-referential structures). */
+const MAX_DEPTH = 64;
+function describe(value) {
+    const t = typeof value;
+    if (t === "function")
+        return "a function";
+    if (t === "symbol")
+        return "a symbol";
+    if (t === "bigint")
+        return "a bigint";
+    if (t === "number")
+        return Number.isNaN(value) ? "NaN" : "a non-finite number";
+    if (value instanceof Date)
+        return "a Date";
+    if (value instanceof RegExp)
+        return "a RegExp";
+    if (value instanceof Map)
+        return "a Map";
+    if (value instanceof Set)
+        return "a Set";
+    if (value instanceof Promise)
+        return "a Promise";
+    if (value instanceof Error)
+        return "an Error";
+    const ctor = value?.constructor?.name;
+    return typeof ctor === "string" && ctor !== "Object" ? `a ${ctor} instance` : "a non-plain object";
+}
+/** A plain object literal (or a null-prototype object) — anything else with `typeof "object"` is a class instance chant refuses to guess at. */
+function isPlainObject(value) {
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function walk(value, path, depth, seen, out) {
+    if (value === null)
+        return;
+    const t = typeof value;
+    if (t === "string" || t === "boolean")
+        return;
+    if (t === "number") {
+        if (!Number.isFinite(value))
+            out.push({ path, found: describe(value) });
+        return;
+    }
+    if (t === "function" || t === "symbol" || t === "bigint" || t === "undefined") {
+        // `undefined` reaches here only from an array slot — an object property
+        // holding `undefined` is skipped by the caller (see the module doc).
+        out.push({ path, found: t === "undefined" ? "undefined" : describe(value) });
+        return;
+    }
+    const obj = value;
+    if (seen.has(obj)) {
+        out.push({ path, found: "a circular reference" });
+        return;
+    }
+    if (depth > MAX_DEPTH) {
+        out.push({ path, found: `nested more than ${MAX_DEPTH} levels deep` });
+        return;
+    }
+    if (Array.isArray(obj)) {
+        seen.add(obj);
+        for (let i = 0; i < obj.length; i++)
+            walk(obj[i], `${path}[${i}]`, depth + 1, seen, out);
+        seen.delete(obj);
+        return;
+    }
+    if (!isPlainObject(obj)) {
+        out.push({ path, found: describe(obj) });
+        return;
+    }
+    seen.add(obj);
+    for (const key of Object.keys(obj)) {
+        const child = obj[key];
+        if (child === undefined)
+            continue; // dropped, equivalent to omitting the key — see the module doc
+        const childPath = path ? `${path}.${key}` : key;
+        walk(child, childPath, depth + 1, seen, out);
+    }
+    seen.delete(obj);
+}
+/**
+ * chant #1131 — report every value ANYWHERE in `value` that cannot cross the
+ * sandbox boundary as JSON, with paths rooted at `rootPath`.
+ *
+ * {@link scanConfigWireSafety} is the config-shaped entry point (it tolerates a
+ * module namespace object at the root); this one takes the value as given, so
+ * an array root (`diagnostics`) or a plain object root both work. Same rules,
+ * same `undefined`-object-property allowance — see the module doc.
+ */
+export function scanValueWireSafety(value, rootPath = "") {
+    const out = [];
+    walk(value, rootPath, 0, new Set(), out);
+    return out;
+}
+/**
+ * Report every value in `config` that cannot cross the sandbox boundary as
+ * JSON. An empty array means a `JSON.parse(JSON.stringify(config))` round-trip
+ * preserves the configuration exactly (modulo `undefined` object properties,
+ * which are dropped — see the module doc).
+ *
+ * `config` itself may be a module namespace object (`await import(...)` with
+ * no `default` export), which is not a plain object; its own enumerable keys
+ * are walked the same way rather than being reported wholesale.
+ */
+export function scanConfigWireSafety(config) {
+    const out = [];
+    if (config === null || typeof config !== "object") {
+        // A non-object config is what `normalizeConfig` already rejects in the
+        // parent; nothing to say about serializability.
+        return out;
+    }
+    const seen = new Set();
+    seen.add(config);
+    for (const key of Object.keys(config)) {
+        const child = config[key];
+        if (child === undefined)
+            continue;
+        walk(child, key, 1, seen, out);
+    }
+    return out;
+}
+/** Render a {@link ConfigWireOffender} list as the body of a build error — one line per offending key, most specific information first. */
+export function formatConfigWireOffenders(configPath, offenders) {
+    const lines = offenders.map((o) => `  ${o.path || "<root>"}: ${o.found}`);
+    return [
+        `Cannot evaluate ${configPath} inside the --sandbox boundary: it holds values that are not data.`,
+        ...lines,
+        `Under --sandbox the config is evaluated in an isolated child process and only JSON crosses back, so every value must be a string, number, boolean, null, array or plain object. Move the offending value out of chant.config.ts (lint rule plugins and policy checks are referenced by path, not embedded), or drop --sandbox for this build.`,
+    ].join("\n");
+}

package/dist/discovery/sandbox/driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../../src/discovery/sandbox/driver.ts"],"names":[],"mappings":"AA4DA,MAAM,WAAW,qBAAqB;IACpC,qIAAqI;IACrI,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oNAAoN;IACpN,SAAS,EAAE,MAAM,CAAC;CACnB;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,EAAE,CAsB3E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAoH3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA6CrE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAgGjF"}
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../../src/discovery/sandbox/driver.ts"],"names":[],"mappings":"AA8DA,MAAM,WAAW,qBAAqB;IACpC,qIAAqI;IACrI,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,oNAAoN;IACpN,SAAS,EAAE,MAAM,CAAC;CACnB;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,EAAE,CAsB3E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAoH3E;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA6CrE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAgGjF"}