sfscanner 0.0.0-stage → 0.1.0

package/dist/v2/metadata-output.js

@@ -0,0 +1,818 @@
+// src/v2/metadata-output.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// src/v2/commands.ts
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+
+// ../scanner-core/src/canonical-json.ts
+function canonicalizeJson(value) {
+  return encodeCanonical(value, /* @__PURE__ */ new Set());
+}
+function encodeCanonical(value, seen) {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("Cannot encode non-finite number as canonical JSON");
+    return JSON.stringify(Object.is(value, -0) ? 0 : value);
+  }
+  if (typeof value !== "object" || value === void 0) {
+    throw new TypeError(`Cannot encode ${typeof value} as canonical JSON`);
+  }
+  if (seen.has(value)) throw new TypeError("Cannot encode cyclic value as canonical JSON");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return encodeArray(value, seen);
+    return encodeObject(value, seen);
+  } finally {
+    seen.delete(value);
+  }
+}
+function encodeArray(value, seen) {
+  const values = Array.from({ length: value.length }, (_, index) => {
+    if (!Object.prototype.hasOwnProperty.call(value, index)) {
+      throw new TypeError("Cannot encode sparse array as canonical JSON");
+    }
+    return encodeCanonical(value[index], seen);
+  });
+  return `[${values.join(",")}]`;
+}
+function encodeObject(value, seen) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new TypeError("Cannot encode a non-plain object as canonical JSON");
+  }
+  if (Object.getOwnPropertySymbols(value).some((symbol) => Object.prototype.propertyIsEnumerable.call(value, symbol))) {
+    throw new TypeError("Cannot encode symbol properties as canonical JSON");
+  }
+  const pairs = Object.keys(value).sort(compareCanonicalStrings).map((key) => `${JSON.stringify(key)}:${encodeCanonical(value[key], seen)}`);
+  return `{${pairs.join(",")}}`;
+}
+function compareCanonicalStrings(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+// ../scanner-core/src/policy/rule-catalog.ts
+var betaRule = (policyId, defaultSeverity, defaultConfidence, precision, cweIds) => ({
+  policyId,
+  defaultSeverity,
+  defaultConfidence,
+  precision,
+  policyEffect: "LEGACY_SCORE",
+  curationAction: "NONE",
+  serveAction: "DISPLAY",
+  cweIds
+});
+var betaDefaultRuleCatalog = [
+  betaRule("N8N_EXECUTE_COMMAND", "CRITICAL", "HIGH", "HIGH", ["CWE-78"]),
+  betaRule("N8N_CODE_NODE", "LOW", "HIGH", "HIGH", ["CWE-94"]),
+  // Literal Authorization values are a hardcoded credential (CWE-798); expression/credential-
+  // driven values that still leaked as a raw header are an insufficiently protected transmission
+  // (CWE-522). Both apply to this rule depending on evidence shape, so both are catalogued.
+  betaRule("RAW_AUTH_HEADER", "HIGH", "MEDIUM", "MEDIUM", ["CWE-798", "CWE-522"]),
+  betaRule("RAW_SECRET_INDICATOR", "HIGH", "MEDIUM", "MEDIUM", ["CWE-798"]),
+  betaRule("UNAPPROVED_DOMAIN", "MEDIUM", "HIGH", "HIGH", []),
+  betaRule("UNKNOWN_NODE_PACKAGE", "LOW", "MEDIUM", "MEDIUM", ["CWE-1357"]),
+  betaRule("WEBHOOK_EXPOSURE", "MEDIUM", "MEDIUM", "MEDIUM", ["CWE-306"])
+];
+var reportOnlyRule = (policyId, defaultSeverity, defaultConfidence, precision, cweIds, owaspAgenticIds) => ({
+  policyId,
+  defaultSeverity,
+  defaultConfidence,
+  precision,
+  policyEffect: "REPORT_ONLY",
+  curationAction: "REVIEW",
+  serveAction: "DISPLAY",
+  cweIds,
+  ...owaspAgenticIds ? { owaspAgenticIds } : {}
+});
+var betaHardenedRuleCatalog = [
+  ...betaDefaultRuleCatalog,
+  // CWE-95 ("Eval Injection") precisely fits only this rule's EVAL/FUNCTION_CONSTRUCTOR
+  // indicators; CHILD_PROCESS_* is closer to CWE-78 and FILESYSTEM_ACCESS to CWE-73. One CWE per
+  // policy ID is a simplification of the eight indicators this rule reports under; see the
+  // `[^js]`/`[^py]` footnotes in docs/scanner/policy-inventory.md.
+  reportOnlyRule("JAVASCRIPT_DYNAMIC_EXECUTION", "HIGH", "HIGH", "HIGH", ["CWE-95"]),
+  reportOnlyRule("PYTHON_DYNAMIC_EXECUTION", "HIGH", "MEDIUM", "MEDIUM", ["CWE-95"]),
+  reportOnlyRule("TAINTED_COMMAND", "CRITICAL", "MEDIUM", "MEDIUM", ["CWE-78"]),
+  reportOnlyRule("TAINTED_SQL_QUERY", "HIGH", "MEDIUM", "MEDIUM", ["CWE-89"]),
+  reportOnlyRule("TAINTED_REQUEST_URL", "HIGH", "MEDIUM", "MEDIUM", ["CWE-918"]),
+  reportOnlyRule("TAINTED_FILE_PATH", "HIGH", "MEDIUM", "MEDIUM", ["CWE-22"]),
+  reportOnlyRule("TAINTED_CODE_INPUT", "HIGH", "MEDIUM", "MEDIUM", ["CWE-94"]),
+  reportOnlyRule("TAINTED_REQUEST_HEADER", "MEDIUM", "MEDIUM", "MEDIUM", ["CWE-113"]),
+  // No CWE is dedicated to LLM prompt injection; CWE-77 ("Command Injection") is the nearest
+  // structural analogy (untrusted data reaching an interpreter that blends instructions and
+  // data). OWASP Agentic's "Prompt Injection" is the precise, purpose-built taxonomy tag and
+  // should be treated as primary; CWE-77 is a bridge for CWE-only tooling.
+  reportOnlyRule("TAINTED_AI_PROMPT", "MEDIUM", "LOW", "LOW", ["CWE-77"], ["Prompt Injection"]),
+  // CWE-269 (Improper Privilege Management) frames the agent as holding privilege it should not
+  // autonomously exercise; the alternative CWE-862 (Missing Authorization) was reviewed and is
+  // also defensible, but the OWASP Agentic "Excessive Agency" pairing does the precise work
+  // either way, so CWE-269 is kept per docs/scanner/policy-inventory.md.
+  reportOnlyRule("AI_AGENT_UNGATED_TOOL", "MEDIUM", "LOW", "LOW", ["CWE-269"], ["Excessive Agency"])
+];
+
+// src/v2/contracts.ts
+var SCAN_CONFIG_SCHEMA_V2 = "n8n-scan-config-v2";
+var ADMITTED_PROFILE_V2 = Object.freeze({ id: "beta-default", version: "2.0.0", digest: "3ca5d69db2554383e22c44afe507cc98e381ea58a7e42aaac0ee8f7497fb4f44" });
+var ADMITTED_PROFILE_SPECIFIERS_V2 = Object.freeze([
+  ADMITTED_PROFILE_V2.id,
+  `${ADMITTED_PROFILE_V2.id}@${ADMITTED_PROFILE_V2.version}`
+]);
+function isAdmittedProfileSpecifierV2(value) {
+  return typeof value === "string" && ADMITTED_PROFILE_SPECIFIERS_V2.includes(value);
+}
+var BUILTIN_AUTHORITIES_V2 = Object.freeze({
+  profile: ADMITTED_PROFILE_V2,
+  rules: Object.freeze({ id: "scanner-core-builtins", version: "2.0.0", digest: "a36d00564bbf8e8c38f05820480782cdc53fdbd3712558850066c4e3f5c3413d", signatureStatus: "VERIFIED" }),
+  semantics: Object.freeze({ id: "scanner-core-builtins", version: "2.0.0", digest: "1bb11f63269d427cb28e141dfe0a6a1512e53c298abdb4d6450545ceb56d11c4" }),
+  limits: Object.freeze({ schemaVersion: "scanner-limits-v2", digest: "fca787753ca88f71cf0d174427f4ac730a7aef1c823aaf73aa1ea72af92b4077" })
+});
+var PROFILE_MANIFEST_DIGEST_V2 = ADMITTED_PROFILE_V2.digest;
+var BUILTIN_RULESET_AUTHORITY_V2 = BUILTIN_AUTHORITIES_V2.rules;
+var BUILTIN_SEMANTICS_AUTHORITY_V2 = BUILTIN_AUTHORITIES_V2.semantics;
+var BUILTIN_LIMITS_AUTHORITY_V2 = BUILTIN_AUTHORITIES_V2.limits;
+var RULE_PACK_DIGEST_V2 = BUILTIN_RULESET_AUTHORITY_V2.digest;
+var SEMANTIC_CATALOGUE_DIGEST_V2 = BUILTIN_SEMANTICS_AUTHORITY_V2.digest;
+var DEFAULT_SCAN_CONFIG_V2 = Object.freeze({
+  schemaVersion: SCAN_CONFIG_SCHEMA_V2,
+  format: "json",
+  profile: ADMITTED_PROFILE_V2.id,
+  failOn: "INFO",
+  requireComplete: false,
+  concurrency: 1,
+  rules: "builtin",
+  catalogue: "builtin",
+  limits: "builtin",
+  include: Object.freeze(["**/*.json"]),
+  exclude: Object.freeze([".git/**", "node_modules/**"]),
+  allowUnsignedDevelopmentRules: false,
+  noColor: false
+});
+var SCAN_CONFIG_V2_FIELDS = Object.freeze([
+  "schemaVersion",
+  "format",
+  "profile",
+  "output",
+  "inputs",
+  "configPath",
+  "failOn",
+  "requireComplete",
+  "concurrency",
+  "rules",
+  "catalogue",
+  "limits",
+  "target",
+  "include",
+  "exclude",
+  "allowUnsignedDevelopmentRules",
+  "noColor"
+]);
+var SCAN_CONFIG_V2_MAX_STRING = 4096;
+var SCAN_CONFIG_V2_MAX_PATTERNS = 1024;
+var SCAN_CONFIG_V2_MAX_CONCURRENCY = 16;
+
+// src/v2/config.ts
+var BUILTIN = { builtin: true };
+var CLI_NAMES = Object.freeze({
+  "fail-on": "failOn",
+  "require-complete": "requireComplete",
+  "max-concurrency": "concurrency",
+  "allow-unsigned-development-rules": "allowUnsignedDevelopmentRules",
+  "no-color": "noColor",
+  config: "configPath"
+});
+var REPEATABLE_CLI = { inputs: true, include: true, exclude: true };
+function loadExplicitConfig(input, options = {}) {
+  const errors = [];
+  const config = parseConfig(input, errors);
+  const cli = readCli(options.cli, errors);
+  if (typeof options.configDirectory !== "undefined" && typeof options.configDirectory !== "string") errors.push("config directory is invalid");
+  if (!config || !cli) return failure(errors);
+  const configPathCount = Number(Object.prototype.hasOwnProperty.call(config, "configPath")) + Number(Object.prototype.hasOwnProperty.call(cli, "configPath")) + Number(Object.prototype.hasOwnProperty.call(cli, "_configPath"));
+  if (configPathCount > 1) errors.push("config path supplied more than once");
+  const merged = Object.assign(/* @__PURE__ */ Object.create(null), DEFAULT_SCAN_CONFIG_V2, config);
+  for (const key of Object.keys(cli)) if (key !== "configPath" && key !== "_configPath") merged[key] = cli[key];
+  if (Object.prototype.hasOwnProperty.call(cli, "configPath")) merged.configPath = cli.configPath;
+  else if (Object.prototype.hasOwnProperty.call(cli, "_configPath")) merged.configPath = cli._configPath;
+  const result = normalize(merged, config, cli, errors);
+  return result ? Object.freeze({ ok: true, config: deepFreeze(result) }) : failure(errors);
+}
+function parseConfig(input, errors) {
+  if (typeof input === "string") {
+    if (input.length > SCAN_CONFIG_V2_MAX_STRING * 16 || duplicateKeys(input)) {
+      errors.push("configuration JSON is invalid");
+      return void 0;
+    }
+    try {
+      input = JSON.parse(input);
+    } catch {
+      errors.push("configuration JSON is invalid");
+      return void 0;
+    }
+  }
+  const value = record(input);
+  if (!value) {
+    errors.push("configuration must be a closed object");
+    return void 0;
+  }
+  for (const key of Object.keys(value)) if (!SCAN_CONFIG_V2_FIELDS.includes(key)) errors.push(`unknown configuration key: ${safeErrorKey(key)}`);
+  if (value.schemaVersion !== "n8n-scan-config-v2") errors.push("unsupported schemaVersion");
+  return Object.keys(value).every((key) => SCAN_CONFIG_V2_FIELDS.includes(key)) ? value : void 0;
+}
+function readCli(input, errors) {
+  if (input === void 0) return {};
+  const value = record(input);
+  if (!value) {
+    errors.push("CLI configuration is invalid");
+    return void 0;
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const [rawKey, rawValue] of Object.entries(value)) {
+    if (rawKey === "config") {
+      if (Object.prototype.hasOwnProperty.call(out, "_configPath")) errors.push("config path supplied more than once");
+      out._configPath = rawValue;
+      continue;
+    }
+    const key = CLI_NAMES[rawKey] ?? rawKey;
+    if (!SCAN_CONFIG_V2_FIELDS.includes(key)) {
+      errors.push(`unknown CLI configuration key: ${safeErrorKey(rawKey)}`);
+      continue;
+    }
+    out[key] = REPEATABLE_CLI[key] === true && typeof rawValue === "string" ? [rawValue] : rawValue;
+  }
+  return out;
+}
+function normalize(value, config, cli, errors) {
+  const out = Object.assign(/* @__PURE__ */ Object.create(null), { schemaVersion: "n8n-scan-config-v2" });
+  const format = value.format;
+  if (format !== "json" && format !== "ndjson" && format !== "sarif" && format !== "table") errors.push("format is invalid");
+  else out.format = format;
+  const profile = value.profile;
+  if (!isAdmittedProfileSpecifierV2(profile)) errors.push("profile is not admitted");
+  else out.profile = ADMITTED_PROFILE_V2.id;
+  if (value.failOn !== "CRITICAL" && value.failOn !== "HIGH" && value.failOn !== "MEDIUM" && value.failOn !== "LOW" && value.failOn !== "INFO") errors.push("failOn is invalid");
+  else out.failOn = value.failOn;
+  for (const key of ["requireComplete", "allowUnsignedDevelopmentRules", "noColor"]) {
+    if (typeof value[key] !== "boolean") errors.push(`${key} is invalid`);
+    else out[key] = value[key];
+  }
+  if (!Number.isSafeInteger(value.concurrency) || value.concurrency < 1 || value.concurrency > SCAN_CONFIG_V2_MAX_CONCURRENCY) errors.push("concurrency is outside the admitted range");
+  else out.concurrency = value.concurrency;
+  for (const key of ["rules", "catalogue"]) {
+    const raw = value[key];
+    if (typeof raw !== "string" || BUILTIN[raw] !== true) errors.push(`${key} is not admitted in built-in-only v2`);
+    else out[key] = "builtin";
+  }
+  for (const key of ["limits", "target", "output", "configPath"]) if (value[key] !== void 0 || Object.prototype.hasOwnProperty.call(value, key)) {
+    const raw = value[key];
+    if (typeof raw !== "string") errors.push(`${key} is invalid`);
+    else {
+      const path = localPath(raw, false, errors, key === "limits");
+      if (path) out[key] = path;
+    }
+  }
+  for (const key of ["inputs", "include", "exclude"]) {
+    const raw = value[key];
+    if (raw === void 0) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) errors.push(`${key} is invalid`);
+      continue;
+    }
+    const items = arrayValues(raw);
+    if (!items || items.length > SCAN_CONFIG_V2_MAX_PATTERNS) {
+      errors.push(`${key} is outside the admitted limit`);
+      continue;
+    }
+    const paths = [];
+    for (const item of items) if (typeof item !== "string") errors.push(`${key} contains an invalid path`);
+    else {
+      const path = localPath(item, true, errors);
+      if (path) paths.push(path);
+    }
+    out[key] = Object.freeze(paths);
+  }
+  if (!Object.prototype.hasOwnProperty.call(config, "include") && !Object.prototype.hasOwnProperty.call(cli, "include")) out.include = DEFAULT_SCAN_CONFIG_V2.include;
+  if (!Object.prototype.hasOwnProperty.call(config, "exclude") && !Object.prototype.hasOwnProperty.call(cli, "exclude")) out.exclude = DEFAULT_SCAN_CONFIG_V2.exclude;
+  return errors.length === 0 ? out : void 0;
+}
+function localPath(raw, pattern, errors, allowBuiltin = false) {
+  if (raw.length === 0 || raw.length > SCAN_CONFIG_V2_MAX_STRING || /[\u0000-\u001f\u007f]/.test(raw)) {
+    errors.push("path is invalid");
+    return void 0;
+  }
+  if (BUILTIN[raw] === true) {
+    if (allowBuiltin) return "builtin";
+    errors.push("built-in marker is not valid for this path");
+    return void 0;
+  }
+  const normalized = raw.replaceAll("\\", "/");
+  if (/^(?:[a-z][a-z\d+.-]*:|\/|[a-z]:)/i.test(normalized)) {
+    errors.push("absolute or remote path is not admitted");
+    return void 0;
+  }
+  const parts = [];
+  for (const part of normalized.split("/")) {
+    if (!part || part === ".") continue;
+    if (part === "..") {
+      if (pattern || parts.length === 0) {
+        errors.push("path escapes its config directory");
+        return void 0;
+      }
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  if (parts.length === 0) {
+    errors.push("path is invalid");
+    return void 0;
+  }
+  return parts.join("/");
+}
+function arrayValues(value) {
+  try {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || Object.getOwnPropertySymbols(value).length > 0) return void 0;
+    const names = Object.getOwnPropertyNames(value);
+    if (names.length !== value.length + 1) return void 0;
+    const output = [];
+    for (let index = 0; index < value.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (!descriptor || !("value" in descriptor)) return void 0;
+      output.push(descriptor.value);
+    }
+    return output;
+  } catch {
+    return void 0;
+  }
+}
+function safeErrorKey(value) {
+  return /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(value) ? value : "field";
+}
+function record(value) {
+  try {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) return void 0;
+    if (Object.getOwnPropertySymbols(value).length > 0) return void 0;
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.getOwnPropertyNames(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) return void 0;
+      out[key] = descriptor.value;
+    }
+    return out;
+  } catch {
+    return void 0;
+  }
+}
+function duplicateKeys(text) {
+  let index = 0;
+  const skip = () => {
+    while (/\s/.test(text[index] ?? "")) index += 1;
+  };
+  const string = () => {
+    index += 1;
+    while (index < text.length) {
+      const char = text[index++];
+      if (char === "\\") index += 1;
+      else if (char === '"') return;
+    }
+    throw new Error();
+  };
+  const value = () => {
+    skip();
+    const char = text[index];
+    if (char === "{") return object();
+    if (char === "[") return array();
+    if (char === '"') {
+      string();
+      return;
+    }
+    const start = index;
+    while (index < text.length && !/[\s,\]}]/.test(text[index])) index += 1;
+    if (start === index) throw new Error();
+  };
+  const object = () => {
+    index += 1;
+    const keys = /* @__PURE__ */ new Set();
+    skip();
+    if (text[index] === "}") {
+      index += 1;
+      return;
+    }
+    while (index < text.length) {
+      skip();
+      if (text[index] !== '"') throw new Error();
+      const start = index;
+      string();
+      const key = text.slice(start, index);
+      if (keys.has(key)) throw new Error();
+      keys.add(key);
+      skip();
+      if (text[index++] !== ":") throw new Error();
+      value();
+      skip();
+      if (text[index] === "}") {
+        index += 1;
+        return;
+      }
+      if (text[index++] !== ",") throw new Error();
+    }
+    throw new Error();
+  };
+  const array = () => {
+    index += 1;
+    skip();
+    if (text[index] === "]") {
+      index += 1;
+      return;
+    }
+    while (index < text.length) {
+      value();
+      skip();
+      if (text[index] === "]") {
+        index += 1;
+        return;
+      }
+      if (text[index++] !== ",") throw new Error();
+    }
+    throw new Error();
+  };
+  try {
+    value();
+    skip();
+    if (index !== text.length) throw new Error();
+    return false;
+  } catch {
+    return true;
+  }
+}
+function failure(errors) {
+  return Object.freeze({ ok: false, code: "INVALID_CONFIG", errors: Object.freeze([...new Set(errors)].sort()) });
+}
+function deepFreeze(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value && typeof value === "object") {
+    if (seen.has(value)) return value;
+    seen.add(value);
+    for (const key of Object.getOwnPropertyNames(value)) deepFreeze(value[key], seen);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+// src/v2/commands.ts
+var CLI_VERSION = "0.1.0";
+var hash = (value) => createHash("sha256").update(canonicalizeJson(value)).digest("hex");
+var targetBody = Object.freeze({ edition: "UNKNOWN", deployment: "UNKNOWN", role: "UNKNOWN", taskRunner: "UNKNOWN", communityPackages: Object.freeze([]), configuration: Object.freeze([]) });
+var TOOL = Object.freeze({ name: "n8n-scan", version: CLI_VERSION, buildDigest: hash({ engine: "secureflow-scanner", version: "2.0.0", profile: ADMITTED_PROFILE_V2, ruleset: BUILTIN_RULESET_AUTHORITY_V2.digest, semantics: BUILTIN_SEMANTICS_AUTHORITY_V2.digest }) });
+var EVIDENCE = { N8N_EXECUTE_COMMAND: ["nodeType"], N8N_CODE_NODE: ["nodeType"], RAW_AUTH_HEADER: ["header", "literalValue"], RAW_SECRET_INDICATOR: ["parameterPath", "secretKind", "indicator", "hasLiteralValue"], UNAPPROVED_DOMAIN: ["hostname"], UNKNOWN_NODE_PACKAGE: ["nodeType", "nodePackage"], WEBHOOK_EXPOSURE: ["authentication"] };
+var EVIDENCE_SCHEMA = { N8N_EXECUTE_COMMAND: "v1.node-type", N8N_CODE_NODE: "v1.node-type", RAW_AUTH_HEADER: "v1.auth-header", RAW_SECRET_INDICATOR: "v1.secret-indicator", UNAPPROVED_DOMAIN: "v1.domain", UNKNOWN_NODE_PACKAGE: "v1.node-package", WEBHOOK_EXPOSURE: "v1.webhook-auth" };
+var PROSE = {
+  N8N_EXECUTE_COMMAND: { title: "Execute Command node can run shell commands", message: "This workflow can execute shell commands.", explanation: "The Execute Command node allows the workflow to launch shell commands from the n8n runtime environment.", whyItMatters: "Shell command access can cross from workflow automation into the host or worker environment that runs n8n.", possibleImpact: "A malicious or compromised workflow path could lead to command execution, file access, lateral movement, or service disruption.", remediation: "Remove the Execute Command node or isolate it behind strict approval.", remediationSteps: ["Remove the Execute Command node when shell access is not explicitly required.", "Replace shell logic with a narrow, reviewed integration or managed service call.", "If it must remain, isolate the workflow runner and require manual approval before execution."] },
+  N8N_CODE_NODE: { title: "Custom code node requires security review", message: "This workflow contains custom script execution.", explanation: "Code and legacy Function nodes can transform data with arbitrary JavaScript inside the workflow runtime.", whyItMatters: "Custom code is harder to audit than declarative node configuration and may handle secrets or external data.", possibleImpact: "Unsafe code can leak data, mishandle credentials, or create behavior that reviewers cannot understand from node settings alone.", remediation: "Review the code path, remove unnecessary scripting, and require approval.", remediationSteps: ["Review the node source code for secret access, outbound requests, and unsafe parsing.", "Move repeatable logic into a reviewed service or reusable library when possible.", "Require approval for changes to custom code nodes in production workflows."] },
+  RAW_AUTH_HEADER: { title: "Raw Authorization header may expose credentials", message: "This node configures a raw Authorization header.", explanation: "The workflow parameters appear to define an Authorization header directly instead of using managed n8n credentials.", whyItMatters: "Raw credential material in node parameters is easier to copy, persist, log, or expose in exported workflow JSON.", possibleImpact: "API keys or bearer tokens can be leaked through workflow exports, scan history, logs, or support bundles.", remediation: "Use n8n credentials or a managed secret reference instead of raw headers.", remediationSteps: ["Move the secret into n8n credentials or an approved secret manager.", "Rotate any token that has already been stored in raw workflow JSON.", "Re-scan after replacing the raw header with a managed credential reference."] },
+  RAW_SECRET_INDICATOR: { title: "Workflow parameters contain raw secret material", message: "This node contains a parameter that looks like a raw secret.", explanation: "The scanner found a parameter key or value pattern commonly used for tokens, passwords, API keys, cookies, or credentials.", whyItMatters: "Raw secrets in workflow JSON can be exposed through exports, scan history, logs, backups, or support bundles.", possibleImpact: "An exposed token or password can allow unauthorized access to connected systems even if the workflow itself is not malicious.", remediation: "Move the value into n8n credentials or an approved secret manager, then rotate any exposed secret.", remediationSteps: ["Move the raw value into n8n credentials or an approved secret manager.", "Rotate the secret if it has already been exported, shared, or stored in history.", "Re-scan the workflow after replacing the raw value with a managed credential reference."] },
+  UNAPPROVED_DOMAIN: { title: "External domain is outside the approved allowlist", message: "This workflow calls a domain outside the approved allowlist.", explanation: "The node parameters contain a URL whose hostname is not present in the approved domain list supplied for this scan.", whyItMatters: "Unexpected outbound domains can indicate data exfiltration, shadow integrations, or environment drift.", possibleImpact: "Workflow data may be sent to an unreviewed third party or an endpoint that is not covered by enterprise controls.", remediation: "Add the domain to the approved list or replace the external call.", remediationSteps: ["Confirm the business owner and purpose for the external domain.", "Add the domain to the approved list only after security and compliance review.", "Replace the call if the destination is unnecessary or untrusted."] },
+  UNKNOWN_NODE_PACKAGE: { title: "Node package is not from an official n8n namespace", message: "This workflow uses a community or custom node package.", explanation: "The node type does not start with an official n8n package namespace, so it comes from a community or custom package.", whyItMatters: "Community and custom packages can add supply-chain, maintenance, and permission risks that differ from core nodes.", possibleImpact: "A vulnerable or unmaintained package could process sensitive workflow data or run unexpected code.", remediation: "Review the package source, version, permissions, and maintenance status.", remediationSteps: ["Verify the package source, maintainer, and version history.", "Check whether the node requires credentials or broad runtime permissions.", "Pin approved versions and remove packages that are not actively maintained."] },
+  WEBHOOK_EXPOSURE: { title: "Webhook trigger lacks clear authentication", message: "This webhook does not show a clear authentication marker.", explanation: "The webhook node appears to accept inbound requests without an explicit authentication mode in the workflow parameters.", whyItMatters: "Unauthenticated inbound endpoints can be abused for spam, data injection, or unexpected workflow execution.", possibleImpact: "External callers may trigger automations, create records, or send data into connected systems without authorization.", remediation: "Require webhook authentication or place the endpoint behind trusted controls.", remediationSteps: ["Enable webhook authentication in n8n when the endpoint is not intentionally public.", "Place the endpoint behind a gateway, allowlist, or rate limiter for production use.", "Monitor webhook usage for unexpected request volume or payloads."] }
+};
+var CAPABILITIES = Object.freeze([
+  { id: "source-normalization", version: "2.0.0", required: true, dependsOn: [], ruleIds: [] },
+  { id: "workflow-insights", version: "2.0.0", required: true, dependsOn: ["source-normalization"], ruleIds: [] },
+  { id: "structural-policies", version: "2.0.0", required: true, dependsOn: ["source-normalization"], ruleIds: Object.freeze(betaDefaultRuleCatalog.map(({ policyId }) => policyId)) },
+  { id: "assessment", version: "2.0.0", required: true, dependsOn: ["workflow-insights", "structural-policies"], ruleIds: [] },
+  { id: "presentation-facts", version: "2.0.0", required: true, dependsOn: ["assessment"], ruleIds: [] }
+]);
+var HARDENED_CAPABILITIES = Object.freeze([
+  CAPABILITIES[0],
+  CAPABILITIES[1],
+  CAPABILITIES[2],
+  { id: "expression-security", version: "2.0.0", required: false, dependsOn: ["source-normalization"], ruleIds: [] },
+  { id: "javascript-security", version: "2.0.0", required: false, dependsOn: ["source-normalization"], ruleIds: ["JAVASCRIPT_DYNAMIC_EXECUTION"] },
+  { id: "python-security", version: "2.0.0", required: false, dependsOn: ["source-normalization"], ruleIds: ["PYTHON_DYNAMIC_EXECUTION"] },
+  { id: "graph-semantics", version: "2.0.0", required: false, dependsOn: ["source-normalization"], ruleIds: [] },
+  { id: "taint-confidentiality", version: "2.0.0", required: false, dependsOn: ["graph-semantics", "expression-security", "javascript-security", "python-security"], ruleIds: [] },
+  { id: "taint-integrity", version: "2.0.0", required: false, dependsOn: ["graph-semantics", "expression-security", "javascript-security", "python-security"], ruleIds: ["TAINTED_COMMAND", "TAINTED_SQL_QUERY", "TAINTED_REQUEST_URL", "TAINTED_FILE_PATH", "TAINTED_CODE_INPUT", "TAINTED_REQUEST_HEADER", "TAINTED_AI_PROMPT"] },
+  { id: "agentic-control", version: "2.0.0", required: false, dependsOn: ["graph-semantics", "taint-confidentiality", "taint-integrity"], ruleIds: ["AI_AGENT_UNGATED_TOOL"] },
+  CAPABILITIES[3],
+  CAPABILITIES[4]
+]);
+function artifacts(profile = ADMITTED_PROFILE_V2.id) {
+  const target = Object.freeze({ ...targetBody, contextDigest: hash(targetBody) });
+  return Object.freeze({ profile: Object.freeze({ id: profile, version: "2.0.0" }), ruleset: Object.freeze({ ...BUILTIN_RULESET_AUTHORITY_V2 }), semantics: Object.freeze({ ...BUILTIN_SEMANTICS_AUTHORITY_V2 }), target, limits: Object.freeze({ schemaVersion: "scanner-limits-v2", digest: BUILTIN_LIMITS_AUTHORITY_V2.digest }) });
+}
+function ruleSummary(entry) {
+  const capabilityId = "structural-policies";
+  return Object.freeze({ ruleId: entry.policyId, revision: "1", effect: entry.policyEffect === "REPORT_ONLY" ? "REPORT_ONLY" : "SCORING", severity: entry.defaultSeverity, confidence: entry.defaultConfidence, capabilityId, evidenceSchemaId: EVIDENCE_SCHEMA[entry.policyId] ?? "v1.policy", remediationId: "r", cweIds: Object.freeze([...entry.cweIds].sort()), owaspAgenticIds: Object.freeze([...entry.owaspAgenticIds ?? []].sort()) });
+}
+function rulesDocumentV2() {
+  return Object.freeze({ schemaVersion: "n8n-scan-rules-v2", tool: TOOL, artifacts: artifacts(), rules: Object.freeze(betaDefaultRuleCatalog.map(ruleSummary)) });
+}
+function explainDocumentV2(ruleId) {
+  const entry = betaDefaultRuleCatalog.find((item) => item.policyId === ruleId);
+  const prose = PROSE[ruleId];
+  if (!entry || !prose) return Object.freeze({ ok: false, code: "USAGE", message: "Unknown rule." });
+  const rule = ruleSummary(entry);
+  return Object.freeze({ ok: true, document: Object.freeze({ schemaVersion: "n8n-scan-explain-v2", tool: TOOL, artifacts: artifacts(), rule, prose: Object.freeze({ ...prose, remediationSteps: Object.freeze([...prose.remediationSteps]) }), evidenceProperties: Object.freeze([...EVIDENCE[ruleId] ?? []]), provenance: Object.freeze({ packDigest: BUILTIN_RULESET_AUTHORITY_V2.digest, semanticsDigest: BUILTIN_SEMANTICS_AUTHORITY_V2.digest }) }) });
+}
+function profilesDocumentV2() {
+  const body = (id, admitted, capabilities, advertised = true) => Object.freeze({ id, version: "2.0.0", admitted, advertised, digest: hash({ schemaVersion: "scanner-profile-v2", id, version: "2.0.0", capabilities, scoringPolicyVersion: "secureflow-risk-v2@2.0.0" }), scoringPolicyVersion: "secureflow-risk-v2@2.0.0", capabilities: Object.freeze(capabilities.map((item) => Object.freeze({ ...item, dependsOn: Object.freeze([...item.dependsOn]), ruleIds: Object.freeze([...item.ruleIds]) }))) });
+  return Object.freeze({ schemaVersion: "n8n-scan-profiles-v2", tool: TOOL, profiles: Object.freeze([body("beta-default", true, CAPABILITIES), body("beta-hardened", false, HARDENED_CAPABILITIES)]) });
+}
+function versionDocumentV2() {
+  return Object.freeze({ schemaVersion: "n8n-scan-version-v2", name: "n8n-scan", cliVersion: CLI_VERSION, engine: Object.freeze({ id: "secureflow-scanner", version: "2.0.0", buildDigest: TOOL.buildDigest }), resultSchemas: Object.freeze(["scanner-result-v1", "scanner-result-v2"]), configSchema: "n8n-scan-config-v2", rulesetDigest: BUILTIN_RULESET_AUTHORITY_V2.digest, semanticsDigest: BUILTIN_SEMANTICS_AUTHORITY_V2.digest, trustStoreDigest: hash({ schemaVersion: "scanner-trust-store-v2", version: "2.0.0", keys: [] }), mode: "offline" });
+}
+function validateConfigDocumentV2(input, configDirectory) {
+  const result = loadExplicitConfig(input, { configDirectory });
+  if (!result.ok) return Object.freeze({ ok: false, code: "USAGE", message: "Configuration is invalid." });
+  return Object.freeze({ ok: true, document: Object.freeze({ schemaVersion: "n8n-scan-config-validation-v2", valid: true, artifacts: artifacts() }) });
+}
+function isAdmittedConfigPathV2(path) {
+  if (typeof path !== "string" || path.length === 0 || path.length > 4096 || /[\u0000-\u001f\u007f]/.test(path)) return false;
+  const normalized = path.replaceAll("\\", "/");
+  if (/^(?:[a-z][a-z\d+.-]*:|\/|[a-z]:|\\\\)/i.test(normalized) || /(?:^|\/)\.\.(?:\/|$)/.test(normalized) || /(?:^|\/)%2e(?:%2e)?(?:\/|$)/i.test(normalized)) return false;
+  return normalized.split("/").some((part) => part !== "" && part !== ".");
+}
+function runCommandV2(command, configInput, configDirectory) {
+  if (command.kind === "scan") return command.profile === "beta-default" ? Object.freeze({ ok: true, command }) : Object.freeze({ ok: false, code: "USAGE", message: "Profile is not admitted." });
+  if (command.kind === "rules") return Object.freeze({ ok: true, document: rulesDocumentV2() });
+  if (command.kind === "profiles") return Object.freeze({ ok: true, document: profilesDocumentV2() });
+  if (command.kind === "version") return Object.freeze({ ok: true, document: versionDocumentV2() });
+  if (command.kind === "explain") return explainDocumentV2(command.ruleId);
+  if (!isAdmittedConfigPathV2(command.path)) return Object.freeze({ ok: false, code: "USAGE", message: "Configuration path is not admitted." });
+  let input = configInput;
+  if (input === void 0) {
+    try {
+      input = readFileSync(command.path, "utf8");
+    } catch {
+      return Object.freeze({ ok: false, code: "USAGE", message: "Configuration could not be read." });
+    }
+  }
+  return validateConfigDocumentV2(input, configDirectory);
+}
+
+// ../../contracts/stable-order.ts
+function compareCanonicalStrings2(left, right) {
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+// src/v2/metadata-validation.ts
+var KEYS = {
+  "n8n-scan-rules-v2": ["schemaVersion", "tool", "artifacts", "rules"],
+  "n8n-scan-explain-v2": ["schemaVersion", "tool", "artifacts", "rule", "prose", "evidenceProperties", "provenance"],
+  "n8n-scan-profiles-v2": ["schemaVersion", "tool", "profiles"],
+  "n8n-scan-version-v2": ["schemaVersion", "name", "cliVersion", "engine", "resultSchemas", "configSchema", "rulesetDigest", "semanticsDigest", "trustStoreDigest", "mode"],
+  "n8n-scan-config-validation-v2": ["schemaVersion", "valid", "artifacts"],
+  tool: ["name", "version", "buildDigest"],
+  artifacts: ["profile", "ruleset", "semantics", "target", "limits"],
+  profileId: ["id", "version"],
+  ruleset: ["id", "version", "digest", "signatureStatus"],
+  semantics: ["id", "version", "digest"],
+  target: ["edition", "deployment", "role", "taskRunner", "communityPackages", "configuration", "contextDigest"],
+  limits: ["schemaVersion", "digest"],
+  rule: ["ruleId", "revision", "effect", "severity", "confidence", "capabilityId", "evidenceSchemaId", "remediationId", "cweIds", "owaspAgenticIds"],
+  prose: ["title", "message", "explanation", "whyItMatters", "possibleImpact", "remediation", "remediationSteps"],
+  provenance: ["packDigest", "semanticsDigest"],
+  profile: ["id", "version", "admitted", "advertised", "digest", "scoringPolicyVersion", "capabilities"],
+  capability: ["id", "version", "required", "dependsOn", "ruleIds"],
+  engine: ["id", "version", "buildDigest"]
+};
+var DIGEST = /^[0-9a-f]{64}$/;
+var fail = () => {
+  throw new TypeError("Invalid metadata document");
+};
+function checkPlain(o) {
+  if (!o || typeof o !== "object" || Array.isArray(o)) return fail();
+  if (Object.getPrototypeOf(o) !== Object.prototype && Object.getPrototypeOf(o) !== null) return fail();
+  if (Object.getOwnPropertySymbols(o).length > 0) return fail();
+  for (const key of Object.getOwnPropertyNames(o)) {
+    const descriptor = Object.getOwnPropertyDescriptor(o, key);
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) return fail();
+  }
+  return o;
+}
+function checkDenseArray(arr) {
+  if (!Array.isArray(arr) || Object.getPrototypeOf(arr) !== Array.prototype || Object.getOwnPropertySymbols(arr).length > 0) return fail();
+  const names = Object.getOwnPropertyNames(arr);
+  if (names.length !== arr.length + 1) return fail();
+  for (const name of names) {
+    if (name === "length") continue;
+    if (!/^(?:0|[1-9]\d*)$/.test(name) || Number(name) >= arr.length) return fail();
+    const descriptor = Object.getOwnPropertyDescriptor(arr, name);
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) return fail();
+  }
+  const length = Object.getOwnPropertyDescriptor(arr, "length");
+  if (!length || !("value" in length) || !Number.isSafeInteger(length.value)) return fail();
+  return arr;
+}
+function safeString(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 4096 || /[\u0000-\u001f\u007f\ud800-\udfff]/.test(value) || /^[a-z][a-z0-9+.-]*:\/\//i.test(value) || /^[A-Za-z]:[\\/]|^\/|^\\\\/.test(value) || /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(value)) return fail();
+}
+function walk(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return;
+  if (typeof value === "string") return safeString(value);
+  if (typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) fail();
+    return;
+  }
+  if (typeof value !== "object") return fail();
+  if (seen.has(value)) return fail();
+  seen.add(value);
+  if (Array.isArray(value)) for (const item of checkDenseArray(value)) walk(item, seen);
+  else for (const item of Object.values(checkPlain(value))) walk(item, seen);
+  seen.delete(value);
+}
+function checkKeys(value, expected) {
+  const object = checkPlain(value);
+  const actual = Object.keys(object);
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) return fail();
+  return object;
+}
+function digest(value) {
+  if (typeof value !== "string" || !DIGEST.test(value)) fail();
+}
+function sortedStrings(value) {
+  const values = checkDenseArray(value);
+  if (values.some((item) => typeof item !== "string")) return fail();
+  for (let i = 1; i < values.length; i += 1) if (compareCanonicalStrings2(values[i - 1], values[i]) >= 0) return fail();
+}
+function artifacts2(value) {
+  const object = checkKeys(value, KEYS.artifacts);
+  checkKeys(object.profile, KEYS.profileId);
+  const ruleset = checkKeys(object.ruleset, KEYS.ruleset);
+  digest(ruleset.digest);
+  if (ruleset.signatureStatus !== "VERIFIED" && ruleset.signatureStatus !== "UNVERIFIED") return fail();
+  checkKeys(object.semantics, KEYS.semantics);
+  const target = checkKeys(object.target, KEYS.target);
+  checkDenseArray(target.communityPackages);
+  checkDenseArray(target.configuration);
+  digest(target.contextDigest);
+  const limits = checkKeys(object.limits, KEYS.limits);
+  if (limits.schemaVersion !== "scanner-limits-v2") return fail();
+  digest(limits.digest);
+}
+function exact(left, right) {
+  if (left === right) return true;
+  if (typeof left !== typeof right || left === null || right === null) return false;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+    return left.every((item, index) => exact(item, right[index]));
+  }
+  if (typeof left !== "object" || typeof right !== "object") return Object.is(left, right);
+  const a = Object.keys(left);
+  const b = Object.keys(right);
+  return a.length === b.length && a.every((key, index) => key === b[index] && exact(left[key], right[key]));
+}
+function authority(schema, root) {
+  if (schema === "n8n-scan-rules-v2") return rulesDocumentV2();
+  if (schema === "n8n-scan-explain-v2") {
+    const result2 = explainDocumentV2(String(root.rule.ruleId));
+    if (!result2.ok) return fail();
+    return result2.document;
+  }
+  if (schema === "n8n-scan-profiles-v2") return profilesDocumentV2();
+  if (schema === "n8n-scan-version-v2") return versionDocumentV2();
+  const result = validateConfigDocumentV2({ schemaVersion: "n8n-scan-config-v2" });
+  if (!result.ok) return fail();
+  return result.document;
+}
+function validateDocumentShape(doc) {
+  walk(doc);
+  const root = checkPlain(doc);
+  const schema = root.schemaVersion;
+  if (typeof schema !== "string" || !Object.prototype.hasOwnProperty.call(KEYS, schema)) return fail();
+  checkKeys(root, KEYS[schema]);
+  if (schema === "n8n-scan-rules-v2") {
+    checkKeys(root.tool, KEYS.tool);
+    artifacts2(root.artifacts);
+    const rules = checkDenseArray(root.rules);
+    for (const rule of rules) {
+      const item = checkKeys(rule, KEYS.rule);
+      sortedStrings(item.cweIds);
+      sortedStrings(item.owaspAgenticIds);
+    }
+  } else if (schema === "n8n-scan-explain-v2") {
+    checkKeys(root.tool, KEYS.tool);
+    artifacts2(root.artifacts);
+    checkKeys(root.rule, KEYS.rule);
+    const prose = checkKeys(root.prose, KEYS.prose);
+    checkDenseArray(prose.remediationSteps);
+    checkDenseArray(root.evidenceProperties);
+    checkKeys(root.provenance, KEYS.provenance);
+  } else if (schema === "n8n-scan-profiles-v2") {
+    checkKeys(root.tool, KEYS.tool);
+    const profiles = checkDenseArray(root.profiles);
+    for (const profile of profiles) {
+      const item = checkKeys(profile, KEYS.profile);
+      for (const capability of checkDenseArray(item.capabilities)) {
+        const value = checkKeys(capability, KEYS.capability);
+        checkDenseArray(value.dependsOn);
+        checkDenseArray(value.ruleIds);
+      }
+    }
+  } else if (schema === "n8n-scan-version-v2") {
+    checkKeys(root.engine, KEYS.engine);
+    checkDenseArray(root.resultSchemas);
+    digest(root.rulesetDigest);
+    digest(root.semanticsDigest);
+    digest(root.trustStoreDigest);
+  } else {
+    if (root.valid !== true) return fail();
+    artifacts2(root.artifacts);
+  }
+  if (!exact(root, authority(schema, root))) return fail();
+}
+
+// src/v2/metadata-output.ts
+function formatTable(headers, rows) {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+  const sep = widths.map((w) => "-".repeat(w)).join("  ");
+  const formatRow = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join("  ");
+  const body = rows.map(formatRow).join("\n");
+  return `${formatRow(headers)}
+${sep}${body ? `
+${body}` : ""}
+`;
+}
+function renderExplainTable(doc) {
+  const { rule: r, prose: p } = doc;
+  const steps = p.remediationSteps.map((s, i) => `  ${i + 1}. ${s}`).join("\n");
+  const ev = doc.evidenceProperties.length ? doc.evidenceProperties.join(", ") : "none";
+  return [`Rule: ${r.ruleId} (${r.severity}, ${r.confidence}, ${r.effect})`, `Title: ${p.title}`, `Message: ${p.message}`, `Explanation: ${p.explanation}`, `Why it matters: ${p.whyItMatters}`, `Possible impact: ${p.possibleImpact}`, `Remediation: ${p.remediation}`, `Remediation steps:
+${steps}`, `Evidence properties: ${ev}`].join("\n\n") + "\n";
+}
+function renderMetadataTableV2(document, _options) {
+  validateDocumentShape(document);
+  if (document.schemaVersion === "n8n-scan-rules-v2") return formatTable(["Rule ID", "Severity", "Confidence", "Effect", "CWE"], document.rules.map((r) => [r.ruleId, r.severity, r.confidence, r.effect, r.cweIds.join(",") || "-"]));
+  if (document.schemaVersion === "n8n-scan-explain-v2") return renderExplainTable(document);
+  if (document.schemaVersion === "n8n-scan-profiles-v2") return formatTable(["Profile", "Version", "Admitted", "Capabilities", "Digest"], document.profiles.map((p) => [p.id, p.version, p.admitted ? "yes" : "no", String(p.capabilities.length), p.digest.slice(0, 16)]));
+  if (document.schemaVersion === "n8n-scan-version-v2") return [`${document.name} v${document.cliVersion} (mode: ${document.mode})`, `Engine: ${document.engine.id} v${document.engine.version} (${document.engine.buildDigest.slice(0, 16)})`, `Config schema: ${document.configSchema}`, `Ruleset digest: ${document.rulesetDigest.slice(0, 16)}`, `Semantics digest: ${document.semanticsDigest.slice(0, 16)}`].join("\n") + "\n";
+  return "Configuration is valid.\n";
+}
+function serializeMetadataJsonV2(document) {
+  validateDocumentShape(document);
+  return `${JSON.stringify(document, null, 2)}
+`;
+}
+function serializeMetadataV2(document, format = "json", options) {
+  if (format === "table") return renderMetadataTableV2(document, options);
+  if (format === "json") return serializeMetadataJsonV2(document);
+  throw new TypeError("Invalid format");
+}
+function emitRulesDocumentV2(format = "json", options) {
+  return serializeMetadataV2(rulesDocumentV2(), format, options);
+}
+function emitExplainDocumentV2(ruleId, format = "json", options) {
+  const res = explainDocumentV2(ruleId);
+  if (!res.ok) return res;
+  return Object.freeze({ ok: true, output: serializeMetadataV2(res.document, format, options) });
+}
+function emitProfilesDocumentV2(format = "json", options) {
+  return serializeMetadataV2(profilesDocumentV2(), format, options);
+}
+function emitVersionDocumentV2(format = "json", options) {
+  return serializeMetadataV2(versionDocumentV2(), format, options);
+}
+function emitConfigValidationDocumentV2(input, format = "json", options) {
+  const res = validateConfigDocumentV2(input, options?.configDirectory);
+  if (!res.ok) return res;
+  return Object.freeze({ ok: true, output: serializeMetadataV2(res.document, format, options) });
+}
+function emitMetadataCommandResultV2(command, configInput, options) {
+  if (command.kind === "scan") return Object.freeze({ ok: false, code: "USAGE", message: "Scan command is not a metadata command." });
+  if (command.kind === "validate-config") {
+    if (!isAdmittedConfigPathV2(command.path)) {
+      return Object.freeze({ ok: false, code: "USAGE", message: "Configuration path is not admitted." });
+    }
+    let input = configInput;
+    if (input === void 0) {
+      try {
+        input = readFileSync2(command.path, "utf8");
+      } catch {
+        return Object.freeze({ ok: false, code: "USAGE", message: "Configuration could not be read." });
+      }
+    }
+    const res2 = validateConfigDocumentV2(input, options?.configDirectory);
+    if (!res2.ok) return res2;
+    return Object.freeze({ ok: true, output: serializeMetadataV2(res2.document, command.format, options) });
+  }
+  const res = runCommandV2(command, configInput, options?.configDirectory);
+  if (!res.ok) return res;
+  if ("command" in res) return Object.freeze({ ok: false, code: "USAGE", message: "Unexpected scan command." });
+  return Object.freeze({ ok: true, output: serializeMetadataV2(res.document, command.format, options) });
+}
+export {
+  emitConfigValidationDocumentV2,
+  emitExplainDocumentV2,
+  emitMetadataCommandResultV2,
+  emitProfilesDocumentV2,
+  emitRulesDocumentV2,
+  emitVersionDocumentV2,
+  renderMetadataTableV2,
+  serializeMetadataJsonV2,
+  serializeMetadataV2
+};