@pho9ubenaa/siro 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.6.1] — 2026-10-02
+
+- Add `--no-config` to skip executable repository configuration, and
+  `--strict-filesystem` / API `rejectSymlinks` to reject native input-path symlinks.
+  Defaults retain automatic config and symlink resolution; neither option is a sandbox.
+- Add finite scan/output budgets, caller overrides (`limits`, CLI `--max-*`) and
+  `DEFAULT_SCAN_LIMITS` / `ScanLimits` exports. Oversized/deep inputs now fail with
+  exit 2; output overflow exits 70 rather than producing a truncated success report.
+- Omit source excerpts from JSON/YAML/TOML syntax diagnostics. Observed finding
+  values are not secret-redacted.
+- Fix argument-limit failures when inspecting large Deno scoped import mappings.
+- Update locked transitive dependencies to brace-expansion 5.0.12, markdown-it 14.3.1
+  and fast-uri 3.1.8 for upstream security fixes.
+- Correct first-run safety examples to use `npx` without a global install.
+- Separate build/verification from OIDC staging of the verified artifact, with
+  release identity, digest and main-ancestry checks.
+
+Node requirements, direct dependency versions and decoded JSON schema 3 remain unchanged.
+
 ## [0.6.0] — 2026-09-29
 
 ### Breaking changes and inspection scope

package/README.md

@@ -33,8 +33,9 @@ Discovery does not imply that every package's installation settings were inspect
 siro detects managers from `packageManager`, lockfiles, and configuration files. If it cannot
 detect one, choose it explicitly, for example `npx @pho9ubenaa/siro lint --pm npm`.
 The CLI may download code through `npx` and imports a repository's `siro.config.*` as executable
-code. Review configurations before running it on an unfamiliar project; see the
-[threat model](docs/threat-model.md).
+code by default. For an unfamiliar project, use `npx @pho9ubenaa/siro lint --no-config --strict-filesystem`
+in an isolated environment without credentials. These flags do not sandbox npx or
+extensions; see the [threat model](docs/threat-model.md).
 
 ## Read findings and add CI
 
@@ -70,6 +71,11 @@ For exclusions and rule overrides, see the [configuration examples](docs/configu
 | `--severity <error\|warn\|info>`          | Set both the display and CI failure threshold; default failure threshold is `error`.      |
 | `--reporter <pretty\|json\|github>`       | Choose terminal, JSON, or GitHub Actions output; `--json` is a JSON shortcut.             |
 
+`--no-config` disables executable configuration; `--strict-filesystem` rejects
+symlink input paths in native data reads. Scans also have finite caller-controlled
+[file, tree, nesting, finding and output budgets](docs/configuration.md#strict-filesystem-and-scan-budgets).
+Overflow fails the check rather than silently skipping inputs.
+
 For a walkthrough and deeper reference, use these guides:
 
 - [Getting started](docs/getting-started.md) walks through findings and CI; [configuration](docs/configuration.md) covers local PM/version selection, discovery and explicit installation scope, executable config, exit codes, and migration from the removed `--workspaces` flag.

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as isSupportedNodeVersion, E as assertDirectory, M as SiroError, N as UsageError, O as isNodeError, S as isSeverity, T as version, _ as PROJECT_TYPES, a as DEFAULT_REPORTER_NAME, b as SEVERITIES, i as BUILTIN_REPORTER_NAMES, k as asAbsPath, l as safeText, m as loadConfig, o as JSON_REPORTER_NAME, r as lintCommand, t as nodeIO, v as isProjectType, w as SUPPORTED_NODE_RANGE, x as isPM, y as PMS } from "./node-io-CAszdmko.mjs";
+import { C as isSeverity, D as asAbsPath, E as version, F as SiroError, I as UsageError, M as DEFAULT_SCAN_LIMITS, N as resolveScanLimits, S as isPM, T as SUPPORTED_NODE_RANGE, _ as PROJECT_TYPES, a as DEFAULT_REPORTER_NAME, b as PMS, i as BUILTIN_REPORTER_NAMES, j as isNodeError, k as assertDirectory, l as safeText, m as loadConfig, o as JSON_REPORTER_NAME, r as lintCommand, t as nodeIO, v as isProjectType, w as isSupportedNodeVersion, x as SEVERITIES, y as isStableVersion } from "./node-io-BpAHyeBG.mjs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseArgs } from "node:util";
@@ -31,6 +31,7 @@ const COMMANDS = ["lint", "check"];
 const isCommandName = (value) => COMMANDS.some((cmd) => cmd === value);
 //#endregion
 //#region src/cli/parse-args.ts
+const LIMIT_FLAGS = new Map(Object.keys(DEFAULT_SCAN_LIMITS).map((key) => [key.replace(/[A-Z]/gu, (letter) => `-${letter.toLowerCase()}`), key]));
 const REPEATABLE_FLAGS = new Set(["exclude", "installation-root"]);
 const VALUE_FLAGS = new Set([
 	"pm",
@@ -38,12 +39,15 @@ const VALUE_FLAGS = new Set([
 	"project-type",
 	"reporter",
 	"severity",
-	...REPEATABLE_FLAGS
+	...REPEATABLE_FLAGS,
+	...LIMIT_FLAGS.keys()
 ]);
 const BOOLEAN_FLAGS = new Set([
 	"help",
 	"version",
-	"json"
+	"json",
+	"no-config",
+	"strict-filesystem"
 ]);
 const parseCommand = (argv) => {
 	const { tokens } = parseArgs({
@@ -78,7 +82,11 @@ const parseCommand = (argv) => {
 		}
 		if (BOOLEAN_FLAGS.has(token.name)) if (token.value !== void 0) error ??= `Flag ${token.rawName} does not accept a value.`;
 		else {
-			if (token.name === "json" && flags.has("json")) error ??= "--json must be specified only once.";
+			if ([
+				"json",
+				"no-config",
+				"strict-filesystem"
+			].includes(token.name) && flags.has(token.name)) error ??= `${token.rawName} must be specified only once.`;
 			flags.set(token.name, true);
 		}
 		else if (VALUE_FLAGS.has(token.name)) {
@@ -116,15 +124,29 @@ const parseCommand = (argv) => {
 	if (flags.has("reporter") && flags.has("json")) throw new UsageError("Invalid reporter selection: use either --reporter or --json.");
 	const reporter = flags.get("reporter");
 	const pmVersion = flags.get("pm-version");
+	const pm = parsePmFlag(flags.get("pm"));
+	if (pmVersion !== void 0 && (!pm || !isStableVersion(pmVersion))) throw new UsageError("--pm-version requires --pm and an exact stable version.");
+	const limits = {};
+	for (const [flag, key] of LIMIT_FLAGS) {
+		const value = flags.get(flag);
+		if (value !== void 0) {
+			if (typeof value !== "string" || !/^\d+$/u.test(value)) throw new UsageError(`${flag} must be a positive safe integer.`);
+			limits[key] = Number(value);
+		}
+	}
+	resolveScanLimits(limits);
 	return {
 		kind: "lint",
 		cwd: asAbsPath(path.resolve(cwd ?? process.cwd())),
-		pm: parsePmFlag(flags.get("pm")),
+		pm,
 		pmVersion: typeof pmVersion === "string" ? pmVersion : void 0,
 		exclude: repeated.get("exclude"),
 		installationRoots: repeated.get("installation-root"),
 		projectType: parseProjectTypeFlag(flags.get("project-type")),
 		severity: parseSeverityFlag(flags.get("severity")),
+		...flags.has("no-config") ? { noConfig: true } : {},
+		...flags.has("strict-filesystem") ? { rejectSymlinks: true } : {},
+		...Object.keys(limits).length ? { limits } : {},
 		reporter: typeof reporter === "string" ? reporter : flags.has("json") ? JSON_REPORTER_NAME : DEFAULT_REPORTER_NAME
 	};
 };
@@ -136,6 +158,8 @@ const PROJECT_TYPES_LIST = PROJECT_TYPES.join("|");
 const SEVERITIES_LIST = SEVERITIES.join("|");
 const FLAG_LINES = {
 	json: "  --json               Shortcut for --reporter json",
+	safety: "  --no-config          Do not probe or execute repository siro.config.*\n  --strict-filesystem  Reject symlink input paths (not a containment sandbox)",
+	limits: "  --max-file-bytes <n>  Bound each input file (default 8388608)\n  --max-total-bytes <n>  Bound all input reads (default 67108864)\n  --max-entries <n>     Bound native directory entries (default 100000)\n  --max-directories <n> Bound discovered directories (default 10000)\n  --max-directory-depth <n> Bound discovery depth (default 128)\n  --max-config-depth <n> Bound configuration nesting (default 128)\n  --max-findings <n>    Bound unfiltered findings (default 50000)\n  --max-output-bytes <n> Bound report output (default 33554432)",
 	pm: `  --pm <name>          Target a specific package manager (${PMS_LIST})`,
 	pmVersion: "  --pm-version <x.y.z>  Target an exact stable PM version (requires --pm)",
 	inspection: "  --exclude <pattern>  Exclude directories from recursive discovery (repeatable)\n  --installation-root <path>  Inspect local install policy here (repeatable; default .)",
@@ -161,12 +185,15 @@ const HELP_ROOT = [
 	"  --help               Show help for siro or a command",
 	"",
 	"LINT FLAGS",
+	FLAG_LINES.safety,
+	FLAG_LINES.limits,
 	FLAG_LINES.reporter,
 	FLAG_LINES.json,
 	FLAG_LINES.severity,
 	"",
 	"EXAMPLES",
 	"  $ siro lint                         # report violations in cwd",
+	"  $ siro lint --no-config --strict-filesystem  # data-only inspection",
 	"  $ siro lint --reporter github       # GitHub Actions annotations",
 	"  $ siro lint --severity warn         # also fail on warnings",
 	"",
@@ -183,6 +210,8 @@ const HELP_LINT = [
 	"  siro check [path] [flags]        (alias)",
 	"",
 	"FLAGS",
+	FLAG_LINES.safety,
+	FLAG_LINES.limits,
 	FLAG_LINES.pm,
 	FLAG_LINES.pmVersion,
 	FLAG_LINES.inspection,
@@ -195,10 +224,11 @@ const HELP_LINT = [
 	"  0  No findings at or above the active threshold",
 	"  1  Findings at or above the threshold (default: error)",
 	"  2  Usage error (bad flag, broken siro.config.ts, unreadable path, …)",
-	"  70 Uncaught exception (a siro bug, or a reporter / custom rule that threw)",
+	"  70 Output failure/limit, or unexpected exception (including trusted extensions)",
 	"",
 	"EXAMPLES",
 	"  $ siro lint                         # default: pretty reporter, fail on errors",
+	"  $ siro lint --no-config --strict-filesystem  # data-only inspection",
 	"  $ siro lint --reporter github       # GitHub Actions annotations",
 	"  $ siro lint --severity warn         # tighten the gate"
 ].join("\n");
@@ -224,12 +254,16 @@ const dispatch = async (cmd, io) => {
 			if (cmd.reason) await io.stderr(`${safeText(cmd.reason)}\n`);
 			await io.stderr(renderHelp());
 			return EXIT_USAGE;
-		case "lint":
+		case "lint": {
 			assertDirectory(cmd.cwd);
-			return loadConfig(cmd.cwd).then((config) => lintCommand({
-				...cmd,
+			const { noConfig, ...options } = cmd;
+			if (noConfig) return lintCommand(options, io);
+			const config = await loadConfig(cmd.cwd);
+			return lintCommand({
+				...options,
 				config
-			}, io));
+			}, io);
+		}
 		default: throw new Error(`Unhandled command kind: ${String(cmd)}`);
 	}
 };

package/dist/index.d.mts

@@ -201,9 +201,24 @@ interface LintResult {
   readonly inspection: Inspection;
 }
 //#endregion
+//#region src/core/contracts/scan-limits.d.ts
+/** Finite per-scan budgets, controlled by the caller, never repository config. */
+interface ScanLimits {
+  readonly maxFileBytes: number;
+  readonly maxTotalBytes: number;
+  readonly maxEntries: number;
+  readonly maxDirectories: number;
+  readonly maxDirectoryDepth: number;
+  readonly maxConfigDepth: number;
+  readonly maxFindings: number;
+  readonly maxOutputBytes: number;
+}
+declare const DEFAULT_SCAN_LIMITS: Readonly<ScanLimits>;
+//#endregion
 //#region src/core/contracts/reporter.d.ts
 interface ReportContext {
   readonly cwd: AbsPath;
+  readonly limits?: ScanLimits;
 }
 interface Reporter<Name extends string = string> {
   readonly name: Name;
@@ -260,6 +275,10 @@ declare const defineConfig: (config: SiroConfig) => SiroConfig;
 interface LintOptions {
   readonly cwd: AbsPath;
   readonly fs?: FileSystem;
+  /** Caller-controlled finite budgets; omitted values use DEFAULT_SCAN_LIMITS. */
+  readonly limits?: Partial<ScanLimits>;
+  /** Reject file/path symlinks in the native adapter; not an atomic containment sandbox. */
+  readonly rejectSymlinks?: boolean;
   /** Applies only to cwd, never to discovered children or additional installation roots. */
   readonly pm?: PM;
   readonly pmVersion?: string;
@@ -397,5 +416,5 @@ declare const version: string;
 //#region src/adapters/node-paths.d.ts
 declare const asAbsPath: (value: string) => AbsPath;
 //#endregion
-export { type AbsPath, BUILTIN_REPORTER_NAMES, type BuiltinReporterName, CONFIG_FILES, type CheckStatus, ConfigError, type ConfigFileRef, type ConfigReadValue, type ConfigValue, type FileSystem, type Finding, type IO, type Inspection, type InstallationRootInput, type KeyPath, type LintCommandOptions, type LintOptions, type LintResult, type PM, PMS, PROJECT_TYPES, type ParsedConfig, type PolicyTarget, type ProjectType, type RelPath, type Remediation, type RepoContext, type ReportContext, type Reporter, type RequireConfigKeyOptions, type RequireConfigKeySpec, type Rule, type RuleBinding, type RuleContext, type RuleSetting, SEVERITIES, type SetKeyOperation, type Severity, type SiroConfig, SiroError, UsageError, type VersionNote, type ViolationStatus, asAbsPath, asRelPath, defineConfig, defineRule, getByPath, githubReporter, isPM, isSeverity, jsonReporter, lint, lintCommand, loadConfig, nodeFileSystem, nodeIO, overrideBindings, prettyReporter, requireConfigKey, version };
+export { type AbsPath, BUILTIN_REPORTER_NAMES, type BuiltinReporterName, CONFIG_FILES, type CheckStatus, ConfigError, type ConfigFileRef, type ConfigReadValue, type ConfigValue, DEFAULT_SCAN_LIMITS, type FileSystem, type Finding, type IO, type Inspection, type InstallationRootInput, type KeyPath, type LintCommandOptions, type LintOptions, type LintResult, type PM, PMS, PROJECT_TYPES, type ParsedConfig, type PolicyTarget, type ProjectType, type RelPath, type Remediation, type RepoContext, type ReportContext, type Reporter, type RequireConfigKeyOptions, type RequireConfigKeySpec, type Rule, type RuleBinding, type RuleContext, type RuleSetting, SEVERITIES, type ScanLimits, type SetKeyOperation, type Severity, type SiroConfig, SiroError, UsageError, type VersionNote, type ViolationStatus, asAbsPath, asRelPath, defineConfig, defineRule, getByPath, githubReporter, isPM, isSeverity, jsonReporter, lint, lintCommand, loadConfig, nodeFileSystem, nodeIO, overrideBindings, prettyReporter, requireConfigKey, version };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { A as asRelPath, D as nodeFileSystem, M as SiroError, N as UsageError, S as isSeverity, T as version, _ as PROJECT_TYPES, b as SEVERITIES, c as jsonReporter, d as overrideBindings, f as requireConfigKey, g as getByPath, h as defineRule, i as BUILTIN_REPORTER_NAMES, j as ConfigError, k as asAbsPath, m as loadConfig, n as lint, p as CONFIG_FILES, r as lintCommand, s as prettyReporter, t as nodeIO, u as githubReporter, x as isPM, y as PMS } from "./node-io-CAszdmko.mjs";
+import { A as nodeFileSystem, C as isSeverity, D as asAbsPath, E as version, F as SiroError, I as UsageError, M as DEFAULT_SCAN_LIMITS, O as asRelPath, P as ConfigError, S as isPM, _ as PROJECT_TYPES, b as PMS, c as jsonReporter, d as overrideBindings, f as requireConfigKey, g as getByPath, h as defineRule, i as BUILTIN_REPORTER_NAMES, m as loadConfig, n as lint, p as CONFIG_FILES, r as lintCommand, s as prettyReporter, t as nodeIO, u as githubReporter, x as SEVERITIES } from "./node-io-BpAHyeBG.mjs";
 //#region src/core/siro-config.ts
 /** Identity helper for type-checked config files. */
 const defineConfig = (config) => config;
 //#endregion
-export { BUILTIN_REPORTER_NAMES, CONFIG_FILES, ConfigError, PMS, PROJECT_TYPES, SEVERITIES, SiroError, UsageError, asAbsPath, asRelPath, defineConfig, defineRule, getByPath, githubReporter, isPM, isSeverity, jsonReporter, lint, lintCommand, loadConfig, nodeFileSystem, nodeIO, overrideBindings, prettyReporter, requireConfigKey, version };
+export { BUILTIN_REPORTER_NAMES, CONFIG_FILES, ConfigError, DEFAULT_SCAN_LIMITS, PMS, PROJECT_TYPES, SEVERITIES, SiroError, UsageError, asAbsPath, asRelPath, defineConfig, defineRule, getByPath, githubReporter, isPM, isSeverity, jsonReporter, lint, lintCommand, loadConfig, nodeFileSystem, nodeIO, overrideBindings, prettyReporter, requireConfigKey, version };
 
 //# sourceMappingURL=index.mjs.map

package/dist/{node-io-CAszdmko.mjs → node-io-BpAHyeBG.mjs}

@@ -1,5 +1,5 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, opendirSync, readSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
-import { readFileSync, readdirSync, statSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import satisfies from "semver/functions/satisfies.js";
 import * as vb from "valibot";
@@ -9,6 +9,7 @@ import { Minimatch } from "minimatch";
 import ini from "ini";
 import { parse as parse$1 } from "smol-toml";
 import { parseDocument } from "yaml";
+import { types } from "node:util";
 import pc from "picocolors";
 //#region src/core/contracts/errors.ts
 var SiroError = class extends Error {
@@ -31,6 +32,8 @@ var UsageError = class extends SiroError {
 		this.name = "UsageError";
 	}
 };
+/** Parser diagnostics constructed from constant classifications, never source excerpts. */
+var ConfigParseError = class extends Error {};
 /**
 * Run `fn` and wrap any non-`ConfigError` failure as a `ConfigError` prefixed
 * with `filePath`. A `ConfigError` that bubbles up from a nested call is re-thrown unchanged so
@@ -41,12 +44,187 @@ const wrapCodecError = (filePath, fn) => {
 		return fn();
 	} catch (error) {
 		if (error instanceof ConfigError) throw error;
-		let msg = String(error);
-		if (error instanceof Error) msg = error.message;
-		throw new ConfigError(`${filePath}: ${msg}`);
+		throw new ConfigError(`${filePath}: ${error instanceof ConfigParseError ? error.message : "Invalid configuration."}`);
 	}
 };
 //#endregion
+//#region src/core/contracts/records.ts
+/** Configuration maps are ordinary objects or null-prototype dictionaries. */
+const isPlainRecord = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+//#endregion
+//#region src/core/contracts/scan-limits.ts
+const DEFAULT_SCAN_LIMITS = Object.freeze({
+	maxFileBytes: 8 * 1024 * 1024,
+	maxTotalBytes: 64 * 1024 * 1024,
+	maxEntries: 1e5,
+	maxDirectories: 1e4,
+	maxDirectoryDepth: 128,
+	maxConfigDepth: 128,
+	maxFindings: 5e4,
+	maxOutputBytes: 32 * 1024 * 1024
+});
+const resolveScanLimits = (input) => {
+	if (input !== void 0 && (!isPlainRecord(input) || Object.keys(input).some((key) => !Object.hasOwn(DEFAULT_SCAN_LIMITS, key)))) throw new UsageError("limits must be an object of known scan limits.");
+	const limits = {
+		...DEFAULT_SCAN_LIMITS,
+		...input
+	};
+	for (const [key, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value <= 0) throw new UsageError(`${key} must be a positive safe integer.`);
+	return limits;
+};
+const SCAN_SCOPE_ADVICE = "Reduce the scan scope. If the target contains independent projects, scan each project directory separately.";
+const checkLimit = (name, value, limits) => {
+	if (value > limits[name]) {
+		const advice = name === "maxFileBytes" ? "Reduce the size of the input file." : SCAN_SCOPE_ADVICE;
+		throw new ConfigError(`Inspection exceeds ${name} (${limits[name]}). ${advice}`);
+	}
+};
+/** Counts UTF-8 without allocating another copy of a potentially large input. */
+const utf8Bytes = (text) => {
+	let bytes = 0;
+	for (const character of text) {
+		const code = character.codePointAt(0);
+		bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+	}
+	return bytes;
+};
+/** Iterative traversal; shared YAML mappings are legal, cycles are not. Root depth is 1. */
+const checkConfigDepth = (value, maxDepth) => {
+	const active = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Map();
+	const pending = [{
+		value,
+		depth: 1
+	}];
+	while (pending.length) {
+		const item = pending.pop();
+		if (item.value === null || typeof item.value !== "object") continue;
+		if (item.leave) {
+			active.delete(item.value);
+			continue;
+		}
+		if (active.has(item.value)) throw new ConfigError("Configuration contains a circular reference.");
+		if (item.depth > maxDepth) throw new ConfigError(`Configuration exceeds maxConfigDepth (${maxDepth}). Simplify the nesting of the configuration.`);
+		if ((seen.get(item.value) ?? 0) >= item.depth) continue;
+		seen.set(item.value, item.depth);
+		active.add(item.value);
+		pending.push({
+			...item,
+			leave: true
+		});
+		for (const child of Object.values(item.value)) pending.push({
+			value: child,
+			depth: item.depth + 1
+		});
+	}
+};
+/** Output budgets are output failures (70), not policy findings or incomplete input (2). */
+const outputBudget = (maxBytes) => {
+	let bytes = 0;
+	return (text) => {
+		bytes += utf8Bytes(text);
+		if (bytes > maxBytes) throw new SiroError(`Output exceeds maxOutputBytes (${maxBytes}). ${SCAN_SCOPE_ADVICE}`, 70);
+	};
+};
+//#endregion
+//#region src/adapters/node-errors.ts
+/** Only the Error and code properties are established by this guard. */
+const isNodeError = (value) => value instanceof Error && "code" in value && typeof value.code === "string";
+//#endregion
+//#region src/adapters/node-file-system.ts
+/** Root ancestors are canonicalized; selected cwd and all below-root components must not be links. */
+const strictPaths = (root) => {
+	const selected = path.resolve(root);
+	if (lstatSync(selected).isSymbolicLink()) throw new ConfigError("Strict filesystem rejects a symlink cwd.");
+	const canonical = realpathSync(selected);
+	return (file) => {
+		const relative = path.relative(root, file);
+		if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) throw new ConfigError("Strict filesystem path escapes cwd.");
+		let current = canonical;
+		for (const component of relative.split(path.sep).filter(Boolean)) {
+			current = path.join(current, component);
+			if (lstatSync(current).isSymbolicLink()) throw new ConfigError(`${file}: strict filesystem rejects symlinks.`);
+		}
+	};
+};
+/** Construct fresh native budgets for each inspection. No counters survive another scan. */
+const createNodeFileSystem = (limits = DEFAULT_SCAN_LIMITS, strictRoot) => {
+	const checkPath = strictRoot === void 0 ? () => {} : strictPaths(strictRoot);
+	let totalBytes = 0;
+	let entries = 0;
+	const regularFile = (file) => {
+		checkPath(file);
+		const stat = statSync(file);
+		if (!stat.isFile()) throw new ConfigError(`${file}: expected a regular file.`);
+		return stat;
+	};
+	return {
+		readDirectories(directory) {
+			checkPath(directory);
+			const stream = opendirSync(directory);
+			const names = [];
+			try {
+				for (let entry = stream.readSync(); entry !== null; entry = stream.readSync()) {
+					checkLimit("maxEntries", ++entries, limits);
+					if (entry.isDirectory()) names.push(entry.name);
+				}
+			} finally {
+				stream.closeSync();
+			}
+			return names;
+		},
+		exists(file) {
+			try {
+				regularFile(file);
+				return true;
+			} catch (error) {
+				if (isNodeError(error) && error.code === "ENOENT") return false;
+				throw error;
+			}
+		},
+		readText(file) {
+			let fd;
+			try {
+				const stat = regularFile(file);
+				checkLimit("maxFileBytes", stat.size, limits);
+				checkLimit("maxTotalBytes", totalBytes + stat.size, limits);
+				fd = openSync(file, constants.O_RDONLY | constants.O_NONBLOCK | (strictRoot === void 0 ? 0 : constants.O_NOFOLLOW ?? 0));
+				if (!fstatSync(fd).isFile()) throw new ConfigError(`${file}: expected a regular file.`);
+				const chunks = [];
+				let size = 0;
+				for (;;) {
+					const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, limits.maxFileBytes - size + 1, limits.maxTotalBytes - totalBytes + 1));
+					const read = readSync(fd, buffer);
+					if (read === 0) break;
+					size += read;
+					totalBytes += read;
+					checkLimit("maxFileBytes", size, limits);
+					checkLimit("maxTotalBytes", totalBytes, limits);
+					chunks.push(buffer.subarray(0, read));
+				}
+				return Buffer.concat(chunks, size).toString("utf8");
+			} catch (error) {
+				if (isNodeError(error) && error.code === "ENOENT") return;
+				throw error;
+			} finally {
+				if (fd !== void 0) closeSync(fd);
+			}
+		}
+	};
+};
+const nodeFileSystem = {
+	readDirectories: (directory) => createNodeFileSystem().readDirectories(directory),
+	exists: (file) => createNodeFileSystem().exists(file),
+	readText: (file) => createNodeFileSystem().readText(file)
+};
+const assertDirectory = (root) => {
+	if (!statSync(root).isDirectory()) throw new UsageError("The lint target must be a directory.");
+};
+//#endregion
 //#region src/core/contracts/paths.ts
 const isRelPath = (value) => typeof value === "string" && value.length > 0 && !value.includes("\0") && !/^[\\/]/u.test(value) && !/^[a-z]:/iu.test(value) && !value.split(/[\\/]/u).includes("..");
 const asRelPath = (value) => {
@@ -75,44 +253,8 @@ const nodePaths = {
 	}
 };
 //#endregion
-//#region src/adapters/node-errors.ts
-/** Only the Error and code properties are established by this guard. */
-const isNodeError = (value) => value instanceof Error && "code" in value && typeof value.code === "string";
-//#endregion
-//#region src/adapters/node-file-system.ts
-const assertRegularFile = (filePath) => {
-	if (!statSync(filePath).isFile()) throw new ConfigError(`${filePath}: expected a regular file.`);
-};
-const nodeFileSystem = {
-	readDirectories(directory) {
-		return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-	},
-	exists(filePath) {
-		try {
-			assertRegularFile(filePath);
-			return true;
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return false;
-			throw error;
-		}
-	},
-	readText(filePath) {
-		try {
-			assertRegularFile(filePath);
-			return readFileSync(filePath, "utf8");
-		} catch (error) {
-			if (isNodeError(error) && error.code === "ENOENT") return;
-			throw error;
-		}
-	}
-};
-const resolveIn = (root, relPath) => nodePaths.resolve(root, relPath);
-const assertDirectory = (root) => {
-	if (!statSync(root).isDirectory()) throw new UsageError("The lint target must be a directory.");
-};
-//#endregion
 //#region package.json
-var version$1 = "0.6.0";
+var version$1 = "0.6.1";
 var engines = { "node": "^22.18.0 || ^24.0.0" };
 //#endregion
 //#region src/version.ts
@@ -122,14 +264,6 @@ const SUPPORTED_NODE_RANGE = engines.node;
 //#region src/adapters/node-version.ts
 const isSupportedNodeVersion = (version) => satisfies(version, SUPPORTED_NODE_RANGE);
 //#endregion
-//#region src/core/contracts/records.ts
-/** Configuration maps are ordinary objects or null-prototype dictionaries. */
-const isPlainRecord = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === Object.prototype || prototype === null;
-};
-//#endregion
 //#region src/core/contracts/pms.ts
 /**
 * Single source of truth for package managers and severities.
@@ -252,7 +386,7 @@ const getByPath = (config, keyPath) => {
 /** Accept only mapping roots while preserving unvalidated values inside them. */
 const toParsedConfig = (value) => {
 	if (isPlainRecord(value)) return value;
-	throw new TypeError("Config root must be a mapping.");
+	throw new ConfigParseError("Config root must be a mapping.");
 };
 //#endregion
 //#region src/core/contracts/config-file-ref.ts
@@ -1794,7 +1928,7 @@ const unpinnedInlineImports = (config) => {
 	const scopes = getByPath(config, ["scopes"]);
 	if (scopes != null) {
 		if (!isPlainRecord(scopes)) throw new ConfigError("deno.json: scopes must be an object.");
-		for (const [scope, mapping] of Object.entries(scopes)) offenders.push(...collectUnpinnedImports(mapping, `scopes[${JSON.stringify(scope)}]`));
+		for (const [scope, mapping] of Object.entries(scopes)) for (const offender of collectUnpinnedImports(mapping, `scopes[${JSON.stringify(scope)}]`)) offenders.push(offender);
 	}
 	return offenders;
 };
@@ -2401,16 +2535,7 @@ const runLint = (opts) => {
 			version: opts.pmVersions?.[pm]
 		}));
 	}
-	const summary = {
-		error: 0,
-		info: 0,
-		warn: 0
-	};
-	for (const finding of findings) summary[finding.severity] += 1;
-	return {
-		findings,
-		summary
-	};
+	return { findings };
 };
 //#endregion
 //#region src/core/contracts/deno-json.ts
@@ -2428,7 +2553,7 @@ const validateDenoMetadata = (config) => {
 //#region src/core/parse-config-file.ts
 const EMPTY_FILE = Object.freeze({});
 /** Create a lazy parser for one repository context; callers own its lifetime. */
-const createConfigParser = (codecFor, ctx) => {
+const createConfigParser = (codecFor, ctx, maxDepth = DEFAULT_SCAN_LIMITS.maxConfigDepth) => {
 	const cache = /* @__PURE__ */ new Map();
 	return (file) => {
 		if (file === void 0) return EMPTY_FILE;
@@ -2441,31 +2566,34 @@ const createConfigParser = (codecFor, ctx) => {
 			return EMPTY_FILE;
 		}
 		const parsed = wrapCodecError(file.path, () => codecFor(file.kind).parse(text));
+		checkConfigDepth(parsed, maxDepth);
 		cache.set(cacheKey, parsed);
 		return parsed;
 	};
 };
 /** Pair the context with a fresh lazy parser; construction performs no reads. */
-const createRepositoryEvaluation = (ctx, codecFor) => ({
+const createRepositoryEvaluation = (ctx, codecFor, maxDepth = DEFAULT_SCAN_LIMITS.maxConfigDepth) => ({
 	ctx,
-	parseConfig: createConfigParser(codecFor, ctx)
+	parseConfig: createConfigParser(codecFor, ctx, maxDepth)
 });
 //#endregion
 //#region src/core/discovery.ts
 /** One context per selected directory, shared by publication and installation passes. */
-const discover = (cwd, fs, excluded, projectType, dependencies) => {
-	if (typeof fs.readDirectories !== "function") throw new ConfigError("FileSystem.readDirectories is required for package discovery; no native filesystem fallback is used.");
+const discover = (cwd, fs, excluded, projectType, dependencies, limits = DEFAULT_SCAN_LIMITS) => {
 	const { paths, createRepoContext, codecFor } = dependencies;
 	const pending = [asRelPath(".")];
 	const directories = [];
 	while (pending.length) {
 		const directory = pending.pop();
+		checkLimit("maxDirectories", directories.length + pending.length + 1, limits);
+		checkLimit("maxDirectoryDepth", directory === "." ? 0 : directory.split("/").length, limits);
 		const absolute = paths.resolve(cwd, directory);
 		let repository;
 		const manifests = [];
 		try {
-			repository = createRepositoryEvaluation(createRepoContext(absolute, fs, projectType), codecFor);
+			repository = createRepositoryEvaluation(createRepoContext(absolute, fs, projectType), codecFor, limits.maxConfigDepth);
 			const { ctx, parseConfig } = repository;
+			checkConfigDepth(ctx.packageJson, limits.maxConfigDepth);
 			if (ctx.packageJson !== void 0) manifests.push("package.json");
 			if (ctx.readText(CONFIG_FILES.denoJson.path) !== void 0) {
 				validateDenoMetadata(parseConfig(CONFIG_FILES.denoJson));
@@ -2487,6 +2615,8 @@ const discover = (cwd, fs, excluded, projectType, dependencies) => {
 			if (!Object.hasOwn(names, i)) throw new ConfigError(`${directory}: FileSystem.readDirectories must return a dense array.`);
 			const child = paths.child(directory, names[i]);
 			if (names[i] === ".git" || names[i] === "node_modules" || excluded(child) || children.has(child)) continue;
+			checkLimit("maxDirectoryDepth", child.split("/").length, limits);
+			checkLimit("maxDirectories", directories.length + pending.length + 1, limits);
 			children.add(child);
 			pending.push(child);
 		}
@@ -2564,6 +2694,38 @@ const rebaseFinding = (directory, finding) => {
 	};
 };
 //#endregion
+//#region src/core/bounded-file-system.ts
+/** Bounds returned data from trusted injected IO; cannot bound allocations inside that IO. */
+const boundedFileSystem = (fs, limits) => {
+	const texts = /* @__PURE__ */ new Map();
+	let bytes = 0;
+	let entries = 0;
+	return {
+		exists: (path) => fs.exists(path),
+		readText(path) {
+			if (!texts.has(path)) {
+				const text = fs.readText(path);
+				if (text !== void 0) {
+					const size = utf8Bytes(text);
+					checkLimit("maxFileBytes", size, limits);
+					bytes += size;
+					checkLimit("maxTotalBytes", bytes, limits);
+				}
+				texts.set(path, text);
+			}
+			return texts.get(path);
+		},
+		readDirectories(path) {
+			const names = fs.readDirectories(path);
+			if (Array.isArray(names)) {
+				entries += names.length;
+				checkLimit("maxEntries", entries, limits);
+			}
+			return names;
+		}
+	};
+};
+//#endregion
 //#region src/core/lint.ts
 const validateLintOptions = (options, paths) => {
 	if (!options || !paths.isAbsolute(options.cwd)) throw new UsageError("cwd must be an absolute filesystem path.");
@@ -2577,12 +2739,15 @@ const validateLintOptions = (options, paths) => {
 const prepareLint = (options, dependencies) => {
 	validateLintOptions(options, dependencies.paths);
 	const config = options.config === void 0 ? void 0 : parseConfig(options.config);
-	const fs = options.fs === void 0 ? dependencies.fileSystem : options.fs;
+	const limits = resolveScanLimits(options.limits);
+	const sourceFs = options.fs === void 0 ? dependencies.fileSystem : options.fs;
+	if (typeof sourceFs.readDirectories !== "function") throw new ConfigError("FileSystem.readDirectories is required for package discovery; no native filesystem fallback is used.");
+	const fs = boundedFileSystem(sourceFs, limits);
 	const excluded = dependencies.compileExclusions(parseExcludes(options.exclude !== void 0 ? options.exclude : config?.exclude ?? []));
 	const installations = parseInstallationRoots(options.installationRoots !== void 0 ? options.installationRoots : config?.installationRoots ?? ["."]);
 	const configured = applyConfig(dependencies.rules, config);
 	const needsCustomTarget = configured.rules.some((rule) => scopeOf(rule.id) === "custom");
-	const discovered = discover(options.cwd, fs, excluded, options.projectType ?? config?.projectType, dependencies);
+	const discovered = discover(options.cwd, fs, excluded, options.projectType ?? config?.projectType, dependencies, limits);
 	for (const entry of installations) if (!discovered.some((item) => item.directory === entry.path)) throw new UsageError(`${entry.path}: installation root must be an existing, selected ordinary directory using its exact enumerated spelling (no symlinks, excluded or hard-skipped paths).`);
 	return {
 		evaluation: {
@@ -2627,13 +2792,14 @@ const prepareLint = (options, dependencies) => {
 				};
 			}),
 			ruleSet: configured.rules,
-			severityOverrides: configured.severityOverrides
+			severityOverrides: configured.severityOverrides,
+			limits
 		},
 		reporters: config?.reporters ?? []
 	};
 };
 const runPreparedLint = (evaluation) => {
-	const { directories, ruleSet, severityOverrides } = evaluation;
+	const { directories, ruleSet, severityOverrides, limits } = evaluation;
 	const findings = [];
 	const manifests = [];
 	const installationRoots = [];
@@ -2676,7 +2842,8 @@ const runPreparedLint = (evaluation) => {
 			throw error;
 		}
 		local.sort((a, b) => (ruleOrder.get(a.ruleId) ?? 0) - (ruleOrder.get(b.ruleId) ?? 0));
-		findings.push(...local.map((finding) => rebaseFinding(directory, finding)));
+		checkLimit("maxFindings", findings.length + local.length, limits);
+		for (const finding of local) findings.push(rebaseFinding(directory, finding));
 	}
 	const summary = {
 		error: 0,
@@ -2739,6 +2906,7 @@ const lintCommand$1 = async (options, io, dependencies, reporters) => {
 	const result = runPreparedLint(prepared.evaluation);
 	const exitCode = exitCodeForLint(result, options.severity ?? "error");
 	const writes = [];
+	const consumeOutput = outputBudget(prepared.evaluation.limits.maxOutputBytes);
 	let outputFailed = false;
 	let outputFailure;
 	const recordFailure = (error) => {
@@ -2749,6 +2917,7 @@ const lintCommand$1 = async (options, io, dependencies, reporters) => {
 	};
 	const track = (write) => (line) => {
 		try {
+			consumeOutput(`${line}\n`);
 			const written = write(line);
 			writes.push(Promise.resolve(written).then(() => {}, recordFailure));
 			return written;
@@ -2761,7 +2930,10 @@ const lintCommand$1 = async (options, io, dependencies, reporters) => {
 		await reporter.format(filterBySeverity(result, options.severity ?? "info"), {
 			stdout: track((line) => io.stdout(line)),
 			stderr: track((line) => io.stderr(line))
-		}, { cwd: options.cwd });
+		}, {
+			cwd: options.cwd,
+			limits: prepared.evaluation.limits
+		});
 	} finally {
 		await Promise.all(writes);
 	}
@@ -2794,32 +2966,29 @@ const parsePackageJson = (value) => {
 	throw new ConfigError(`package.json: ${field ? `${field}: ` : ""}${issue.message}`);
 };
 //#endregion
-//#region src/adapters/repo-context.ts
-const tryParseJson = (text) => {
+//#region src/adapters/codecs/json.ts
+/** Strict JSON; runtime SyntaxError messages may disclose arbitrary source bytes. */
+const parseJson = (text, maxDepth = DEFAULT_SCAN_LIMITS.maxConfigDepth) => {
+	let value;
 	try {
-		return JSON.parse(text);
-	} catch (error) {
-		let errMsg = String(error);
-		if (error instanceof Error) errMsg = error.message;
-		throw new ConfigError(`package.json: invalid JSON — ${errMsg}`);
+		value = JSON.parse(text.trim());
+	} catch {
+		throw new ConfigParseError("invalid JSON");
 	}
+	checkConfigDepth(value, maxDepth);
+	return value;
 };
-const readPackageJson = (raw) => {
-	return parsePackageJson(tryParseJson(raw.trim()));
-};
-const createRepoContext = (root, fs = nodeFileSystem, projectType) => {
-	if (fs === nodeFileSystem) assertDirectory(root);
-	const packageFile = resolveIn(root, asRelPath("package.json"));
-	const raw = fs.readText(packageFile);
-	const texts = new Map([[packageFile, raw]]);
-	const readText = (relPath) => {
-		const file = resolveIn(root, relPath);
-		if (!texts.has(file)) texts.set(file, fs.readText(file));
-		return texts.get(file);
-	};
-	const exists = (relPath) => fs.exists(resolveIn(root, relPath));
-	let packageJson = void 0;
-	if (typeof raw !== "undefined") packageJson = readPackageJson(raw);
+const jsonCodec = { parse(text) {
+	return toParsedConfig(parseJson(text));
+} };
+//#endregion
+//#region src/adapters/repo-context.ts
+/** Read caching and budgets belong to the scan's supplied filesystem. */
+const createRepoContext = (root, fs, projectType, maxDepth = DEFAULT_SCAN_LIMITS.maxConfigDepth) => {
+	const readText = (relative) => fs.readText(nodePaths.resolve(root, relative));
+	const raw = readText(asRelPath("package.json"));
+	const packageJson = raw === void 0 ? void 0 : parsePackageJson(wrapCodecError("package.json", () => parseJson(raw, maxDepth)));
+	const exists = (relative) => fs.exists(nodePaths.resolve(root, relative));
 	return {
 		exists,
 		packageJson,
@@ -2842,37 +3011,71 @@ const coerce = (raw) => {
 	if (typeof raw !== "string") return raw;
 	return coerceBoolean(raw) ?? coerceInteger(raw) ?? raw;
 };
+/**
+* Coerces unquoted scalars on read so rule checks can match by typed
+* value (`true === true`, `7 === 7`). Strings whose lexeme matches
+* `true`/`false`/`-?\d+` lose their string-ness — this is by design for
+* the npm schema, where rule values are booleans / integers / the empty
+* string. Don't model a customRule around a string like `"0"` on this
+* codec; pick yaml/json if you need lossless arbitrary-string reads.
+*/
+const iniCodec = { parse(text) {
+	const raw = toParsedConfig(ini.parse(text));
+	const config = {};
+	for (const [key, value] of Object.entries(raw)) if (Array.isArray(value)) config[key] = value.map((elem) => coerce(elem));
+	else if (typeof value === "object" && value !== null) config[key] = toParsedConfig(value);
+	else config[key] = coerce(value);
+	return config;
+} };
+//#endregion
+//#region src/adapters/codecs/toml.ts
+const tomlCodec = { parse(text) {
+	if (text.trim() === "") return {};
+	const input = text.startsWith("") ? text.slice(1) : text;
+	let value;
+	try {
+		value = parse$1(input);
+	} catch {
+		throw new ConfigParseError("Invalid TOML syntax.");
+	}
+	return toParsedConfig(value);
+} };
 //#endregion
-//#region src/adapters/codecs/store.ts
-const CODECS = {
-	json: { parse(text) {
-		const trimmed = text.trim();
-		return toParsedConfig(JSON.parse(trimmed));
-	} },
-	npmrc: { parse(text) {
-		const raw = toParsedConfig(ini.parse(text));
-		const config = {};
-		for (const [key, value] of Object.entries(raw)) if (Array.isArray(value)) config[key] = value.map((elem) => coerce(elem));
-		else if (typeof value === "object" && value !== null) config[key] = toParsedConfig(value);
-		else config[key] = coerce(value);
-		return config;
-	} },
-	toml: { parse(text) {
-		if (text.trim() === "") return {};
-		return toParsedConfig(parse$1(text.startsWith("") ? text.slice(1) : text));
-	} },
-	yaml: { parse(text) {
-		if (text.trim() === "") return {};
-		const document = parseDocument(text);
-		if (document.errors.length > 0) throw document.errors[0];
+//#region src/adapters/codecs/yaml.ts
+const parseYaml = (text, maxDepth = DEFAULT_SCAN_LIMITS.maxConfigDepth) => {
+	if (text.trim() === "") return {};
+	let value;
+	try {
+		const document = parseDocument(text, { prettyErrors: false });
+		if (document.errors.length) throw new ConfigParseError("Invalid YAML syntax.");
 		if (document.contents === null) return {};
-		return toParsedConfig(document.toJS({ onAnchor: (value, count) => {
-			if (count > 1) JSON.stringify(value);
-		} }));
-	} }
+		value = document.toJS();
+	} catch (error) {
+		if (error instanceof ConfigParseError) throw error;
+		if (error instanceof Error && error.message.includes("Excessive alias count")) throw new ConfigParseError("Excessive alias count in YAML.");
+		throw new ConfigParseError("Invalid YAML.");
+	}
+	try {
+		checkConfigDepth(value, maxDepth);
+	} catch (error) {
+		if (error instanceof ConfigError) throw error;
+		throw new ConfigParseError("Invalid YAML structure.");
+	}
+	return toParsedConfig(value);
 };
-/** Look up the codec for a parseable kind. Total — every CodecKind has one. */
-const codecFor = (kind) => CODECS[kind];
+//#endregion
+//#region src/adapters/codecs/store.ts
+const CODECS = {
+	json: jsonCodec,
+	npmrc: iniCodec,
+	toml: tomlCodec,
+	yaml: { parse: (text) => parseYaml(text) }
+};
+const createCodecFor = (limits) => (kind) => ({ parse(text) {
+	const parsed = kind === "json" ? toParsedConfig(parseJson(text, limits.maxConfigDepth)) : kind === "yaml" ? parseYaml(text, limits.maxConfigDepth) : CODECS[kind].parse(text);
+	checkConfigDepth(parsed, limits.maxConfigDepth);
+	return parsed;
+} });
 //#endregion
 //#region src/adapters/reporters/github.ts
 const COMMAND = {
@@ -2885,12 +3088,15 @@ const escapeProp = (raw) => escapeData(raw).replaceAll(":", "%3A").replaceAll(",
 /** Emit GitHub Actions workflow commands (annotations on PRs). */
 const githubReporter = {
 	async format(result, io, context) {
+		const consume = outputBudget(context.limits?.maxOutputBytes ?? DEFAULT_SCAN_LIMITS.maxOutputBytes);
 		for (const finding of result.findings) {
 			let file = "";
 			if (finding.file) file = `file=${escapeProp(path.resolve(context.cwd, finding.file))},`;
 			let body = `[${finding.pm ?? "package"}] ${finding.directory}: ${finding.message}`;
 			if (finding.docs) body += ` (${finding.docs})`;
-			await io.stdout(`::${COMMAND[finding.severity]} ${file}title=${escapeProp(finding.ruleId)}::${escapeData(body)}`);
+			const line = `::${COMMAND[finding.severity]} ${file}title=${escapeProp(finding.ruleId)}::${escapeData(body)}`;
+			consume(`${line}\n`);
+			await io.stdout(line);
 		}
 	},
 	name: "github"
@@ -2902,6 +3108,66 @@ const safeText = (text) => text.replace(/[\u0000-\u001f\u007f-\u009f\u061c\u200e
 /** JSON syntax and decoded values stay identical; CI must not parse legacy commands in it. */
 const safeJsonText = (json) => json.replace(/[\u007f-\u009f\u061c\u200e\u200f\u2028-\u202e\u2066-\u2069]/gu, (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`).replaceAll("##[", "\\u0023\\u0023[");
 //#endregion
+//#region src/adapters/reporters/bounded-json.ts
+const omitted = (value) => value === void 0 || typeof value === "function" || typeof value === "symbol";
+/** Serialize incrementally into bounded chunks before allocating the final JSON document.
+* JSON primitives use the native encoder; containers preserve its own-key/array/toJSON semantics.
+*/
+const boundedJson = (input, maxBytes, maxDepth) => {
+	const consume = outputBudget(maxBytes);
+	const chunks = [];
+	const active = /* @__PURE__ */ new Set();
+	const emit = (text) => {
+		const escaped = safeJsonText(text);
+		consume(escaped);
+		chunks.push(escaped);
+	};
+	const normalize = (value, key) => {
+		if (value !== null && (typeof value === "object" || typeof value === "function" || typeof value === "bigint")) {
+			const toJSON = value.toJSON;
+			if (typeof toJSON === "function") value = Reflect.apply(toJSON, value, [key]);
+		}
+		if (types.isNumberObject(value)) return +value;
+		if (types.isStringObject(value)) return `${value}`;
+		if (types.isBooleanObject(value)) return Boolean.prototype.valueOf.call(value);
+		if (types.isBigIntObject(value)) return BigInt.prototype.valueOf.call(value);
+		return value;
+	};
+	const serialize = (value, depth) => {
+		if (typeof value === "bigint") throw new TypeError("Do not know how to serialize a BigInt");
+		if (value === null || typeof value !== "object") {
+			emit(JSON.stringify(value) ?? "null");
+			return;
+		}
+		if (active.has(value)) throw new TypeError("Cannot serialize a circular report.");
+		if (depth > maxDepth) throw new TypeError("Report nesting exceeds the configured depth.");
+		active.add(value);
+		const array = Array.isArray(value);
+		emit(array ? "[" : "{");
+		let count = 0;
+		const entry = (key, raw) => {
+			const child = normalize(raw, key);
+			if (!array && omitted(child)) return;
+			emit(`${count++ === 0 ? "\n" : ",\n"}${"  ".repeat(depth)}`);
+			if (!array) {
+				emit(JSON.stringify(key));
+				emit(": ");
+			}
+			serialize(omitted(child) ? null : child, depth + 1);
+		};
+		if (array) {
+			const length = value.length;
+			for (let index = 0; index < length; index++) entry(String(index), value[index]);
+		} else for (const key of Object.keys(value)) entry(key, value[key]);
+		if (count) emit(`\n${"  ".repeat(depth - 1)}`);
+		emit(array ? "]" : "}");
+		active.delete(value);
+	};
+	serialize(normalize(input, ""), 1);
+	consume("\n");
+	return chunks.join("");
+};
+//#endregion
 //#region src/adapters/reporters/json.ts
 /**
 * Versioned machine-readable output — the public contract consumed by
@@ -2910,14 +3176,14 @@ const safeJsonText = (json) => json.replace(/[\u007f-\u009f\u061c\u200e\u200f\u2
 */
 const SCHEMA_VERSION = 3;
 const jsonReporter = {
-	async format(result, io) {
-		await io.stdout(safeJsonText(JSON.stringify({
+	async format(result, io, context) {
+		await io.stdout(boundedJson({
 			schemaVersion: SCHEMA_VERSION,
 			siroVersion: version,
 			findings: result.findings,
 			summary: result.summary,
 			inspection: result.inspection
-		}, void 0, 2)));
+		}, context.limits?.maxOutputBytes ?? DEFAULT_SCAN_LIMITS.maxOutputBytes, (context.limits?.maxConfigDepth ?? DEFAULT_SCAN_LIMITS.maxConfigDepth) + 16));
 	},
 	name: "json"
 };
@@ -2963,9 +3229,11 @@ const buildRenderCtx = (io) => {
 	};
 };
 const prettyReporter = {
-	async format(result, io) {
+	async format(result, io, context) {
 		const lines = [];
+		const consume = outputBudget(context.limits?.maxOutputBytes ?? DEFAULT_SCAN_LIMITS.maxOutputBytes);
 		const collect = (line) => {
+			consume(`${line}\n`);
 			lines.push(line);
 		};
 		const ctx = buildRenderCtx({
@@ -2998,20 +3266,36 @@ const JSON_REPORTER_NAME = jsonReporter.name;
 const BUILTIN_REPORTER_NAMES = BUILTINS.map((rep) => rep.name);
 /** Later registrations replace earlier reporters with the same name. */
 const createRegistry = (extras = []) => new Map([...BUILTINS, ...extras].map((reporter) => [reporter.name, reporter]));
-const dependencies = {
-	rules: createBuiltinRules({
-		now: () => Date.now(),
-		parse: (value) => Date.parse(value)
-	}),
-	fileSystem: nodeFileSystem,
-	paths: nodePaths,
-	createRepoContext,
-	codecFor,
-	compileExclusions
+//#endregion
+//#region src/runtime.ts
+/** Read time at evaluation, never at module initialization. */
+const rules = createBuiltinRules({
+	now: () => Date.now(),
+	parse: (value) => Date.parse(value)
+});
+const dependenciesFor = (options) => {
+	if (!options || !nodePaths.isAbsolute(options.cwd)) throw new UsageError("cwd must be an absolute filesystem path.");
+	const limits = resolveScanLimits(options.limits);
+	if (options.rejectSymlinks !== void 0 && typeof options.rejectSymlinks !== "boolean") throw new UsageError("rejectSymlinks must be a boolean.");
+	const native = options.fs === void 0 || options.fs === nodeFileSystem;
+	if (options.rejectSymlinks && !native) throw new UsageError("rejectSymlinks requires the native filesystem; an injected FileSystem is trusted code.");
+	if (native) assertDirectory(options.cwd);
+	return {
+		rules,
+		fileSystem: native ? createNodeFileSystem(limits, options.rejectSymlinks ? options.cwd : void 0) : options.fs,
+		paths: nodePaths,
+		createRepoContext: (root, fs, projectType) => createRepoContext(root, fs, projectType, limits.maxConfigDepth),
+		codecFor: createCodecFor(limits),
+		compileExclusions
+	};
 };
+const nativeOptions = (options) => options?.fs === nodeFileSystem ? {
+	...options,
+	fs: void 0
+} : options;
 /** Public Node API: callers can replace the filesystem without assembling the application. */
-const lint = (options) => lint$1(options, dependencies);
-const lintCommand = (options, io) => lintCommand$1(options, io, dependencies, {
+const lint = (options) => lint$1(nativeOptions(options), dependenciesFor(options));
+const lintCommand = async (options, io) => lintCommand$1(nativeOptions(options), io, dependenciesFor(options), {
 	defaultName: DEFAULT_REPORTER_NAME,
 	createRegistry
 });
@@ -3058,6 +3342,6 @@ const createNodeIO = (stdout, stderr) => ({
 });
 const nodeIO = createNodeIO(process.stdout, process.stderr);
 //#endregion
-export { asRelPath as A, isSupportedNodeVersion as C, nodeFileSystem as D, assertDirectory as E, SiroError as M, UsageError as N, isNodeError as O, isSeverity as S, version as T, PROJECT_TYPES as _, DEFAULT_REPORTER_NAME as a, SEVERITIES as b, jsonReporter as c, overrideBindings as d, requireConfigKey as f, getByPath as g, defineRule as h, BUILTIN_REPORTER_NAMES as i, ConfigError as j, asAbsPath as k, safeText as l, loadConfig as m, lint as n, JSON_REPORTER_NAME as o, CONFIG_FILES as p, lintCommand as r, prettyReporter as s, nodeIO as t, githubReporter as u, isProjectType as v, SUPPORTED_NODE_RANGE as w, isPM as x, PMS as y };
+export { nodeFileSystem as A, isSeverity as C, asAbsPath as D, version as E, SiroError as F, UsageError as I, DEFAULT_SCAN_LIMITS as M, resolveScanLimits as N, asRelPath as O, ConfigError as P, isPM as S, SUPPORTED_NODE_RANGE as T, PROJECT_TYPES as _, DEFAULT_REPORTER_NAME as a, PMS as b, jsonReporter as c, overrideBindings as d, requireConfigKey as f, getByPath as g, defineRule as h, BUILTIN_REPORTER_NAMES as i, isNodeError as j, assertDirectory as k, safeText as l, loadConfig as m, lint as n, JSON_REPORTER_NAME as o, CONFIG_FILES as p, lintCommand as r, prettyReporter as s, nodeIO as t, githubReporter as u, isProjectType as v, isSupportedNodeVersion as w, SEVERITIES as x, isStableVersion as y };
 
-//# sourceMappingURL=node-io-CAszdmko.mjs.map
+//# sourceMappingURL=node-io-BpAHyeBG.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pho9ubenaa/siro",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Security best-practices linter for the npm ecosystem (npm, pnpm, deno, bun, yarn, aube).",
   "keywords": [
     "aube",