/**
 * Gate: every browser script this package serves must parse.
 *
 * Run via `bun run check` from the package root, beside the trailing-newline
 * gate. `tsc` never sees `src/dashboard/app.js` — it is plain browser JS,
 * shipped as an asset and loaded by a `<script>` tag — and no test executes
 * it, so nothing in the pipeline had an opinion about whether it was even
 * syntactically valid.
 *
 * It was not. 0.19.0 shipped an `app.js` carrying four `__omp_shell("…")`
 * fragments where `!answer.ok` and `!confirmDestructive(` should have been:
 * the authoring session wrote the file through a Python eval path, whose
 * IPython-style `!cmd` shell escape rewrote every line that began with `!`.
 * A single SyntaxError takes the whole script with it, so the dashboard
 * rendered its static `<h1>` and nothing else — no token prompt, no fleet —
 * and looked, from the outside, like an auth or data problem (#981).
 *
 * A parse is the whole check. It is not a linter and has no opinion about
 * style: it asks the one question a served script must answer yes to.
 */

import { execFileSync } from "node:child_process";
import { readFileSync } from "node:fs";
import { join } from "node:path";

/** Tracked browser scripts, repo-root-relative. */
export const BROWSER_SCRIPTS: readonly string[] = ["omp/src/dashboard/app.js"];

/**
 * The parse error for one script, or null when it parses. Uses Bun's own
 * transpiler: a full parse of the source, without executing a line of it (the
 * script drives a DOM this process does not have).
 */
export function parseFailure(source: string, path: string): string | null {
  try {
    new Bun.Transpiler({ loader: "js", target: "browser" }).transformSync(source);
    return null;
  } catch (err) {
    const message = err instanceof Error ? err.message : String(err);
    return `${path}: ${message.split("\n")[0]}`;
  }
}

/** One violation line per unparseable script, so a run names every offender. */
export function findViolations(
  paths: readonly string[],
  read: (path: string) => string,
): string[] {
  const violations: string[] = [];
  for (const path of paths) {
    const failure = parseFailure(read(path), path);
    if (failure !== null) violations.push(failure);
  }
  return violations;
}

function repoRoot(): string {
  return execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
}

if (import.meta.main) {
  const root = repoRoot();
  const violations = findViolations(BROWSER_SCRIPTS, (path) =>
    readFileSync(join(root, path), "utf8"),
  );
  if (violations.length > 0) {
    for (const violation of violations) console.error(violation);
    console.error(`browser script gate: ${violations.length} script(s) do not parse`);
    process.exit(1);
  }
  console.log("browser script gate: ok");
}