@noctcore/harness 0.1.0

package/dist/cli.js

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { readFileSync as readFileSync2, realpathSync } from "fs";
+import path3 from "path";
+import process from "process";
+import { fileURLToPath } from "url";
+
+// src/lint-meta/ctx.ts
+import { spawnSync } from "child_process";
+import { existsSync, globSync, readFileSync } from "fs";
+import path from "path";
+function toPosixRel(rel) {
+  return rel.replace(/\\/g, "/");
+}
+function normalizeText(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+var EXEC_MAX_BUFFER = 16 * 1024 * 1024;
+function createNodeCtx(root) {
+  return {
+    root,
+    read(rel) {
+      const abs = path.join(root, toPosixRel(rel));
+      if (!existsSync(abs)) return null;
+      return normalizeText(readFileSync(abs, "utf8"));
+    },
+    exists(rel) {
+      return existsSync(path.join(root, toPosixRel(rel)));
+    },
+    glob(pattern) {
+      return Array.from(globSync(pattern, { cwd: root })).map(toPosixRel);
+    },
+    exec(cmd) {
+      const res = spawnSync(cmd, {
+        cwd: root,
+        shell: true,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: EXEC_MAX_BUFFER
+      });
+      return {
+        code: typeof res.status === "number" ? res.status : 1,
+        stdout: res.stdout ?? "",
+        stderr: res.stderr ?? ""
+      };
+    }
+  };
+}
+
+// src/lint-meta/registry.ts
+import { pathToFileURL } from "url";
+var DEFAULT_REGISTRY_RELATIVE_PATH = ".nightcore/lint-meta/registry.js";
+var defaultImporter = (absPath) => import(pathToFileURL(absPath).href);
+function isMetaRule(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const r = v;
+  return typeof r.id === "string" && typeof r.run === "function";
+}
+function extractRules(mod) {
+  if (typeof mod !== "object" || mod === null) return null;
+  const m = mod;
+  const def = m.default;
+  const candidates = [
+    m.META_RULES,
+    def?.META_RULES,
+    m.default
+  ];
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate) && candidate.every(isMetaRule)) return candidate;
+  }
+  return null;
+}
+async function loadRegistry(absRegistryPath, importer = defaultImporter) {
+  let mod;
+  try {
+    mod = await importer(absRegistryPath);
+  } catch (err) {
+    return { rules: [], error: err instanceof Error ? err.message : String(err) };
+  }
+  const rules = extractRules(mod);
+  if (rules === null) {
+    return {
+      rules: [],
+      error: "the registry must export `META_RULES` (a named export, or the default) as an array of { id, run } rule objects"
+    };
+  }
+  return { rules };
+}
+
+// src/lint-meta/run.ts
+function runMetaRules(rules, ctx, onRule) {
+  const outcomes = [];
+  for (const rule of rules) {
+    onRule?.(rule);
+    const ciCritical = rule.ciCritical === true;
+    try {
+      outcomes.push({ id: rule.id, ciCritical, violations: rule.run(ctx), threw: null });
+    } catch (err) {
+      outcomes.push({
+        id: rule.id,
+        ciCritical,
+        violations: [],
+        threw: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return outcomes;
+}
+function reportMetaOutcomes(outcomes) {
+  let criticalCount = 0;
+  let totalViolations = 0;
+  const lines = [];
+  for (const outcome of outcomes) {
+    if (outcome.threw !== null) {
+      lines.push(`[ERROR] ${outcome.id}: rule threw \u2014 ${outcome.threw}`);
+      criticalCount += 1;
+      continue;
+    }
+    for (const v of outcome.violations) {
+      totalViolations += 1;
+      const tag = outcome.ciCritical ? "ERROR" : "info";
+      lines.push(`[${tag}] ${v.rule} (${v.file}): ${v.message}`);
+      if (outcome.ciCritical) criticalCount += 1;
+    }
+  }
+  return { criticalCount, totalViolations, lines };
+}
+function exitCodeFor(report) {
+  return report.criticalCount > 0 ? 1 : 0;
+}
+
+// src/manifest.ts
+import path2 from "path";
+var MANIFEST_RELATIVE_PATH = path2.join(".nightcore", "harness.json");
+var DEFAULT_CHECK_TIMEOUT_MS = 3e5;
+var SUPPORTED_SCHEMA_MAJOR = 1;
+function manifestPath(dir) {
+  return path2.join(dir, MANIFEST_RELATIVE_PATH);
+}
+function resolveSchema(raw) {
+  if (raw === void 0 || raw === null) return { tooNew: false, found: SUPPORTED_SCHEMA_MAJOR };
+  const n = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isFinite(n)) return { tooNew: true, found: Number.NaN };
+  const major = Math.floor(n);
+  return { tooNew: major > SUPPORTED_SCHEMA_MAJOR, found: major };
+}
+function planCheck(entry) {
+  if (typeof entry !== "object" || entry === null) return null;
+  const cfg = entry;
+  if (typeof cfg.name !== "string" || cfg.name.trim() === "") return null;
+  if (cfg.enabled === false) return null;
+  const kind = typeof cfg.kind === "string" ? cfg.kind : "";
+  if (kind === "shell") return null;
+  const command = typeof cfg.command === "string" ? cfg.command.trim() : "";
+  if (command === "") return null;
+  const tokens = command.split(/\s+/).filter((t) => t.length > 0);
+  const program = tokens[0];
+  if (program === void 0) return null;
+  const args = tokens.slice(1);
+  const declared = cfg.timeoutMs;
+  const timeoutMs = typeof declared === "number" && Number.isFinite(declared) && declared > 0 ? Math.floor(declared) : DEFAULT_CHECK_TIMEOUT_MS;
+  return { name: cfg.name, kind, command, program, args, timeoutMs };
+}
+function loadChecks(dir, read) {
+  const raw = read(manifestPath(dir));
+  if (raw === null) return { kind: "no-config" };
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return { kind: "no-config" };
+  }
+  if (typeof value !== "object" || value === null) return { kind: "no-config" };
+  const root = value;
+  const schema = resolveSchema(root.schemaVersion);
+  if (schema.tooNew) return { kind: "schema-too-new", found: schema.found };
+  const entries = root.checks;
+  if (!Array.isArray(entries)) return { kind: "no-config" };
+  const checks = [];
+  for (const entry of entries) {
+    const planned = planCheck(entry);
+    if (planned !== null) checks.push(planned);
+  }
+  return { kind: "ready", checks };
+}
+
+// src/run.ts
+var TAIL_LIMIT = 4e3;
+function tailOutput(stdout, stderr) {
+  let combined = stdout;
+  if (stderr.length > 0) combined += `
+${stderr}`;
+  if (combined.length > TAIL_LIMIT) {
+    return `\u2026${combined.slice(combined.length - TAIL_LIMIT)}`;
+  }
+  return combined;
+}
+function timeoutMessage(timeoutMs) {
+  return `timed out after ${timeoutMs}ms (the check was killed; it may hang or need a higher timeoutMs)`;
+}
+function interpret(res, timeoutMs) {
+  const timedOut = res.error?.code === "ETIMEDOUT" || res.signal != null;
+  if (timedOut) {
+    return { status: "failed", output: timeoutMessage(timeoutMs) };
+  }
+  if (res.error) {
+    const detail = res.error.message ?? res.error.code ?? "unknown error";
+    return { status: "failed", output: `failed to launch: ${detail}` };
+  }
+  if (res.status === 0) {
+    return { status: "passed", exitCode: 0 };
+  }
+  return {
+    status: "failed",
+    exitCode: res.status ?? void 0,
+    output: tailOutput(res.stdout, res.stderr)
+  };
+}
+function emptyPass() {
+  return { passed: true, checks: [] };
+}
+function runChecks(planned, runDir, spawn, onCommand) {
+  if (planned.length === 0) return emptyPass();
+  const checks = [];
+  let failedCheck;
+  for (const check of planned) {
+    onCommand?.(check);
+    const start = Date.now();
+    const res = spawn(check.program, check.args, {
+      cwd: runDir,
+      timeoutMs: check.timeoutMs
+    });
+    const durationMs = Date.now() - start;
+    const outcome = interpret(res, check.timeoutMs);
+    if (outcome.status === "failed" && failedCheck === void 0) {
+      failedCheck = check.name;
+    }
+    checks.push({
+      name: check.name,
+      kind: check.kind,
+      command: check.command,
+      status: outcome.status,
+      exitCode: outcome.exitCode,
+      output: outcome.output,
+      durationMs
+    });
+  }
+  const result = { passed: failedCheck === void 0, checks };
+  if (failedCheck !== void 0) result.failedCheck = failedCheck;
+  return result;
+}
+function fixInstruction(result) {
+  const failed = result.checks.filter((c) => c.status === "failed");
+  if (failed.length === 0) {
+    return "The Structure-Lock check failed. Fix the project's harness checks before this work can be verified or merged.";
+  }
+  let out = `The Structure-Lock check failed: ${failed.length} project harness check${failed.length === 1 ? "" : "s"} did not pass. They MUST all pass before this work can be verified or merged. Re-run each one locally and fix every violation it reports:`;
+  for (const c of failed) {
+    out += `
+
+--- \`${c.name}\` ---
+Command: ${c.command}
+
+Output:
+${c.output ?? "(no output captured)"}`;
+  }
+  return out;
+}
+
+// src/cli.ts
+var HELP = `@noctcore/harness \u2014 portable Structure-Lock runner
+
+Usage:
+  harness [check] [options]      Run the checks declared in .nightcore/harness.json
+  harness lint-meta [options]    Run the portable lint-meta rules from the enumerated registry
+
+Options:
+  --dir <path>        Target directory to operate in (default: current directory)
+  --registry <path>   lint-meta only: the rule registry to load
+                      (default: ${DEFAULT_REGISTRY_RELATIVE_PATH}, relative to --dir)
+  --json              check only: emit the machine-readable result to stdout instead of a summary
+  --version           Print the runner version and exit
+  --help              Print this help and exit
+
+Exit codes:
+  0  every check/rule passed (or nothing is configured to enforce)
+  1  a check failed, a rule reported a critical violation or threw, or the manifest requires a newer runner
+  2  a usage error`;
+function parseArgs(argv, cwd) {
+  let command = "check";
+  let sawCommand = false;
+  let dir = cwd;
+  let registry;
+  let json = false;
+  let help = false;
+  let version = false;
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === void 0) continue;
+    if (arg === "--json") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      version = true;
+    } else if (arg === "--dir") {
+      const next = argv[i + 1];
+      if (next !== void 0) {
+        dir = next;
+        i += 1;
+      }
+    } else if (arg.startsWith("--dir=")) {
+      dir = arg.slice("--dir=".length);
+    } else if (arg === "--registry") {
+      const next = argv[i + 1];
+      if (next !== void 0) {
+        registry = next;
+        i += 1;
+      }
+    } else if (arg.startsWith("--registry=")) {
+      registry = arg.slice("--registry=".length);
+    } else if (!arg.startsWith("-") && !sawCommand) {
+      command = arg;
+      sawCommand = true;
+    }
+  }
+  return { command, dir: path3.resolve(cwd, dir), registry, json, help, version };
+}
+function readVersion() {
+  try {
+    const raw = readFileSync2(new URL("../package.json", import.meta.url), "utf8");
+    const pkg = JSON.parse(raw);
+    return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function nodeIO() {
+  return {
+    cwd: process.cwd(),
+    read(absolutePath) {
+      try {
+        return readFileSync2(absolutePath, "utf8");
+      } catch {
+        return null;
+      }
+    },
+    spawn(program, args, options) {
+      const res = spawnSync2(program, args, {
+        cwd: options.cwd,
+        timeout: options.timeoutMs,
+        killSignal: "SIGKILL",
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        maxBuffer: 16 * 1024 * 1024
+      });
+      const err = res.error;
+      return {
+        status: res.status,
+        signal: res.signal,
+        stdout: res.stdout ?? "",
+        stderr: res.stderr ?? "",
+        error: err ? { code: err.code, message: err.message } : void 0
+      };
+    },
+    stdout: (line) => process.stdout.write(`${line}
+`),
+    stderr: (line) => process.stderr.write(`${line}
+`),
+    importModule: defaultImporter
+  };
+}
+function runCheck(parsed, io) {
+  const outcome = loadChecks(parsed.dir, io.read);
+  if (outcome.kind === "no-config") {
+    if (parsed.json) {
+      io.stdout(JSON.stringify(emptyPass()));
+    } else {
+      io.stdout("No structure lock configured \u2014 nothing to enforce.");
+    }
+    return 0;
+  }
+  if (outcome.kind === "schema-too-new") {
+    const label = Number.isFinite(outcome.found) ? String(outcome.found) : "an unrecognized value";
+    io.stderr(
+      `This .nightcore/harness.json declares schemaVersion ${label}, which this runner does not understand. This bundle was authored by a newer Nightcore \u2014 upgrade @noctcore/harness.`
+    );
+    return 1;
+  }
+  const result = runChecks(outcome.checks, parsed.dir, io.spawn, (check) => {
+    const line = `\u2192 ${check.name}: ${check.command}`;
+    if (parsed.json) io.stderr(line);
+    else io.stdout(line);
+  });
+  if (parsed.json) {
+    io.stdout(JSON.stringify(result));
+    return result.passed ? 0 : 1;
+  }
+  for (const check of result.checks) {
+    const mark = check.status === "passed" ? "\u2713" : "\u2717";
+    const exit = check.exitCode != null ? ` (exit ${check.exitCode})` : "";
+    io.stdout(`${mark} ${check.name}${exit}`);
+  }
+  if (result.passed) {
+    const n = result.checks.length;
+    io.stdout(`
+Structure lock passed (${n} check${n === 1 ? "" : "s"}).`);
+    return 0;
+  }
+  io.stderr(`
+${fixInstruction(result)}`);
+  return 1;
+}
+async function runLintMeta(parsed, io) {
+  const registryPath = parsed.registry ? path3.resolve(parsed.dir, parsed.registry) : path3.join(parsed.dir, DEFAULT_REGISTRY_RELATIVE_PATH);
+  if (io.read(registryPath) === null) {
+    io.stdout(
+      `No lint-meta registry at ${registryPath} \u2014 nothing to enforce. (Point --registry at your rule registry, or commit one at ${DEFAULT_REGISTRY_RELATIVE_PATH}.)`
+    );
+    return 0;
+  }
+  const loaded = await loadRegistry(registryPath, io.importModule ?? defaultImporter);
+  if (loaded.error !== void 0) {
+    io.stderr(`Failed to load the lint-meta registry at ${registryPath}: ${loaded.error}`);
+    return 1;
+  }
+  const n = loaded.rules.length;
+  io.stdout(`lint-meta: running ${n} rule${n === 1 ? "" : "s"} from ${registryPath}`);
+  const ctx = createNodeCtx(parsed.dir);
+  const outcomes = runMetaRules(loaded.rules, ctx, (rule) => io.stdout(`\u2192 ${rule.id}`));
+  const report = reportMetaOutcomes(outcomes);
+  for (const line of report.lines) io.stderr(line);
+  if (report.lines.length === 0) io.stdout("lint-meta: no violations");
+  return exitCodeFor(report);
+}
+function runCli(argv, io = nodeIO()) {
+  const parsed = parseArgs(argv, io.cwd);
+  if (parsed.help) {
+    io.stdout(HELP);
+    return 0;
+  }
+  if (parsed.version) {
+    io.stdout(readVersion());
+    return 0;
+  }
+  if (parsed.command === "check") return runCheck(parsed, io);
+  if (parsed.command === "lint-meta") return runLintMeta(parsed, io);
+  io.stderr(`Unknown command: ${parsed.command}. Run \`harness --help\`.`);
+  return 2;
+}
+function isMainModule() {
+  try {
+    const entry = process.argv[1];
+    if (entry === void 0) return false;
+    return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  void Promise.resolve(runCli(process.argv.slice(2))).then((code) => {
+    process.exit(code);
+  });
+}
+export {
+  nodeIO,
+  runCli
+};

package/dist/index.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_BASELINE_DIR: () => DEFAULT_BASELINE_DIR,
+  isGrandfathered: () => isGrandfathered,
+  loadBaseline: () => loadBaseline,
+  serializeBaseline: () => serializeBaseline
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lint-meta/baseline.ts
+var DEFAULT_BASELINE_DIR = ".nightcore/lint-meta/baselines";
+function loadBaseline(ctx, ruleId, baselineDir = DEFAULT_BASELINE_DIR) {
+  const raw = ctx.read(`${baselineDir}/${ruleId}.json`);
+  if (raw === null) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return isNumberMap(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function isGrandfathered(baseline, key, current) {
+  const frozen = baseline[key];
+  return frozen !== void 0 && current <= frozen;
+}
+function serializeBaseline(map) {
+  const sorted = {};
+  for (const key of Object.keys(map).sort()) {
+    const value = map[key];
+    if (value !== void 0) sorted[key] = value;
+  }
+  return `${JSON.stringify(sorted, null, 2)}
+`;
+}
+function isNumberMap(v) {
+  return typeof v === "object" && v !== null && Object.values(v).every((n) => typeof n === "number");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_BASELINE_DIR,
+  isGrandfathered,
+  loadBaseline,
+  serializeBaseline
+});

package/dist/index.d.cts

@@ -0,0 +1,136 @@
+export { C as CheckStatus, M as ManifestOutcome, P as PlannedCheck, a as StructureLockCheck, b as StructureLockResult } from './run-B6_KI2bV.cjs';
+
+/**
+ * The PORTABLE lint-meta contract — the types a target repo's generated
+ * `lint-meta-rule` artifacts implement and import from `@noctcore/harness`.
+ *
+ * This is an owned COPY of the Nightcore-internal `tools/lint-meta/types.ts`
+ * (the engine that enforces what ESLint cannot reach: cross-file contracts,
+ * non-JS files, config parity). It is reproduced here, not imported, so the
+ * published package carries the whole contract with ZERO runtime dependency on
+ * the monorepo — a generated rule in a stranger's repo does
+ * `import type { IMetaRule } from '@noctcore/harness'` and nothing else.
+ *
+ * Rules are pure functions of an {@link IMetaCtx} and return {@link IViolation}s;
+ * the runner exits non-zero when any `ciCritical` rule reports one (or throws).
+ */
+interface IMetaCtx {
+    /** Absolute repo root the rule reads relative to. */
+    readonly root: string;
+    /** Read a repo-relative file (LF-normalized), or `null` if it does not exist. */
+    read(rel: string): string | null;
+    /** Whether a repo-relative path exists. */
+    exists(rel: string): boolean;
+    /** Glob repo-relative paths (cwd = {@link root}). */
+    glob(pattern: string): string[];
+    /** Run a shell command at {@link root}; never throws. */
+    exec(cmd: string): {
+        code: number;
+        stdout: string;
+        stderr: string;
+    };
+}
+interface IViolation {
+    file: string;
+    rule: string;
+    message: string;
+    /**
+     * 1-indexed source location, when the rule can pinpoint one. Optional and
+     * additive: the text reporter ignores it (it surfaces `file`/`rule`/`message`
+     * only), so a rule may omit it.
+     */
+    line?: number;
+    column?: number;
+}
+interface IMetaRule {
+    id: string;
+    category: 'config' | 'source-text' | 'supply-chain' | 'ci' | 'testing';
+    description: string;
+    /** When true, a violation fails CI (the runner exits non-zero). */
+    ciCritical?: boolean;
+    run(ctx: IMetaCtx): IViolation[];
+    /**
+     * Ratcheting rules implement this to snapshot the CURRENT offenders as a frozen
+     * baseline (a flat `metric-key → number` map). A rule's `run` then grandfathers
+     * any offender still within its recorded value (see `baseline.ts`). Omit for
+     * strict rules.
+     */
+    baseline?(ctx: IMetaCtx): Record<string, number>;
+}
+
+/**
+ * The generic lint-meta ratchet — a faithful port of `tools/lint-meta/baseline.ts`.
+ *
+ * A baseline is a committed `<baselineDir>/<rule-id>.json` — a flat `key → number`
+ * map freezing today's offenders at their current metric. The ratchet is one-way:
+ * an offender that is recorded AND has not grown past its frozen value is
+ * grandfathered (suppressed); a NEW offender, or a recorded one that GREW, is a
+ * live violation. As each offender is fixed, its entry is deleted (or lowered),
+ * never raised — the frozen debt only shrinks.
+ *
+ * The `key` is opaque to this module: a rule with more than one metric family
+ * namespaces its keys (`size:<file>`, `manifest:<file>`) so one flat map serves both.
+ *
+ * The only portability change from the internal engine is the baseline HOME: the
+ * Nightcore engine hardcodes `tools/lint-meta/baselines/`, whereas a portable rule
+ * ships its baselines under {@link DEFAULT_BASELINE_DIR} (overridable per call).
+ */
+
+/** Where a portable rule's committed baselines live, relative to the repo root. */
+declare const DEFAULT_BASELINE_DIR = ".nightcore/lint-meta/baselines";
+/** Load a rule's committed baseline, or `{}` when none exists yet. */
+declare function loadBaseline(ctx: IMetaCtx, ruleId: string, baselineDir?: string): Record<string, number>;
+/**
+ * Whether `current` for `key` is grandfathered by `baseline`: recorded AND not
+ * grown past the frozen value. A key absent from the baseline is never
+ * grandfathered (a new offender always fails); a recorded key whose current value
+ * is `<=` its record passes (the ratchet permits staying same-or-shrinking).
+ */
+declare function isGrandfathered(baseline: Record<string, number>, key: string, current: number): boolean;
+/** Serialize a baseline map with sorted keys for a stable, diff-friendly file. */
+declare function serializeBaseline(map: Record<string, number>): string;
+
+/**
+ * Public type surface of `@noctcore/harness`. Exposes the
+ * `.nightcore/harness.json` manifest shape, the `StructureLockResult`-shaped
+ * verdict the runner emits (camelCase, wire-compatible with the Rust
+ * `StructureLockResult` / `StructureLockCheck`), AND the portable lint-meta
+ * contract (`IMetaRule` / `IMetaCtx` / `IViolation`) a target repo's generated
+ * `lint-meta-rule` artifacts implement.
+ *
+ * This barrel exists so generated artifacts and downstream tooling can
+ * `import type` from the published package.
+ */
+
+/** One check as declared in `.nightcore/harness.json`. */
+interface HarnessManifestCheck {
+    /** The logical check name (e.g. `folder-per-component`). */
+    name: string;
+    /** The harness kind (e.g. `lint-plugin`, `ast-grep`). Free-form on the wire. */
+    kind: string;
+    /** The exact command line to run (e.g. `npx eslint .`). */
+    command?: string;
+    /** Optional config path for the underlying tool (informational). */
+    configPath?: string;
+    /** Per-check wall-clock timeout in milliseconds (`> 0`, else the default). */
+    timeoutMs?: number;
+    /** Whether the check participates in the gate. Defaults to `true`. */
+    enabled?: boolean;
+}
+/** The `.nightcore/harness.json` manifest the runner reads. */
+interface HarnessManifest {
+    /**
+     * The manifest MAJOR schema version. Absent ⇒ treated as `1`. A higher MAJOR
+     * than the runner supports reds the build (upgrade the runner).
+     */
+    schemaVersion?: number;
+    /** The checks the runner enforces. Absent/empty ⇒ nothing to enforce. */
+    checks?: HarnessManifestCheck[];
+    /**
+     * The Nightcore agent-runtime policy block. Carried for Nightcore-driven
+     * consumers; the CI runner does not interpret it.
+     */
+    policy?: Record<string, unknown>;
+}
+
+export { DEFAULT_BASELINE_DIR, type HarnessManifest, type HarnessManifestCheck, type IMetaCtx, type IMetaRule, type IViolation, isGrandfathered, loadBaseline, serializeBaseline };