@epikodelabs/testify 1.0.16

package/bin/jasmine

@@ -0,0 +1,1053 @@
+#!/usr/bin/env node
+import { createRequire as ___createRequire } from "module";
+const require2 = ___createRequire(import.meta.url);
+const ___fileURLToPath = require2("url").fileURLToPath;
+const ___path = require2("path");
+const __filename = ___fileURLToPath(import.meta.url);
+const __dirname = ___path.dirname(__filename);
+import * as fs from "fs";
+import fs__default from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+import "util";
+const scriptRel = "modulepreload";
+const assetsURL = function(dep) {
+  return "/" + dep;
+};
+const seen = {};
+const __vitePreload = function preload(baseModule, deps, importerUrl) {
+  let promise = Promise.resolve();
+  if (deps && deps.length > 0) {
+    let allSettled = function(promises$2) {
+      return Promise.all(promises$2.map((p) => Promise.resolve(p).then((value$1) => ({
+        status: "fulfilled",
+        value: value$1
+      }), (reason) => ({
+        status: "rejected",
+        reason
+      }))));
+    };
+    document.getElementsByTagName("link");
+    const cspNonceMeta = document.querySelector("meta[property=csp-nonce]");
+    const cspNonce = cspNonceMeta?.nonce || cspNonceMeta?.getAttribute("nonce");
+    promise = allSettled(deps.map((dep) => {
+      dep = assetsURL(dep);
+      if (dep in seen) return;
+      seen[dep] = true;
+      const isCss = dep.endsWith(".css");
+      const cssSelector = isCss ? '[rel="stylesheet"]' : "";
+      if (document.querySelector(`link[href="${dep}"]${cssSelector}`)) return;
+      const link = document.createElement("link");
+      link.rel = isCss ? "stylesheet" : scriptRel;
+      if (!isCss) link.as = "script";
+      link.crossOrigin = "";
+      link.href = dep;
+      if (cspNonce) link.setAttribute("nonce", cspNonce);
+      document.head.appendChild(link);
+      if (isCss) return new Promise((res, rej) => {
+        link.addEventListener("load", res);
+        link.addEventListener("error", () => rej(/* @__PURE__ */ new Error(`Unable to preload CSS for ${dep}`)));
+      });
+    }));
+  }
+  function handlePreloadError(err$2) {
+    const e$1 = new Event("vite:preloadError", { cancelable: true });
+    e$1.payload = err$2;
+    window.dispatchEvent(e$1);
+    if (!e$1.defaultPrevented) throw err$2;
+  }
+  return promise.then((res) => {
+    for (const item of res || []) {
+      if (item.status !== "rejected") continue;
+      handlePreloadError(item.reason);
+    }
+    return baseModule().catch(handlePreloadError);
+  });
+};
+const MAX_WIDTH = 63;
+const ANSI_FULL_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/g;
+function wrapLine(text, width, indentation = 0, mode = "char") {
+  text = text.replace(/\r?\n/g, " ").replace(/[\uFEFF\xA0\t]/g, " ").replace(/\s{2,}/g, " ").trim();
+  const indent = " ".repeat(indentation);
+  const indentWidth = indent.length;
+  if (width <= indentWidth) width = indentWidth + 1;
+  const availableWidth = width - indentWidth;
+  return mode === "char" ? wrapByChar(text, availableWidth, indent) : wrapByWord(text, availableWidth, indent);
+}
+function wrapByChar(text, available, indent) {
+  const lines = [];
+  let buf = "";
+  let vis = 0;
+  const tokens = text.split(ANSI_FULL_REGEX);
+  for (const token of tokens) {
+    if (ANSI_FULL_REGEX.test(token)) {
+      buf += token;
+      continue;
+    }
+    for (const ch of [...token]) {
+      if (vis >= available) {
+        lines.push(indent + buf);
+        buf = "";
+        vis = 0;
+      }
+      buf += ch;
+      vis++;
+    }
+  }
+  if (buf) lines.push(indent + buf);
+  return lines;
+}
+function wrapByWord(text, available, indent) {
+  const lines = [];
+  let buf = "";
+  let vis = 0;
+  let word = "";
+  let wordVis = 0;
+  const flushWord = () => {
+    if (!word) return;
+    if (wordVis > available) {
+      for (const ch of [...word]) {
+        if (vis >= available) {
+          lines.push(indent + buf.trimEnd());
+          buf = "";
+          vis = 0;
+        }
+        buf += ch;
+        vis++;
+      }
+    } else {
+      if (vis + wordVis > available && vis > 0) {
+        lines.push(indent + buf.trimEnd());
+        buf = "";
+        vis = 0;
+      }
+      buf += word;
+      vis += wordVis;
+    }
+    word = "";
+    wordVis = 0;
+  };
+  for (const ch of [...text]) {
+    if (/\s/.test(ch)) {
+      flushWord();
+      if (vis < available && vis > 0) {
+        buf += " ";
+        vis++;
+      }
+    } else {
+      word += ch;
+      wordVis++;
+    }
+  }
+  flushWord();
+  if (buf) lines.push(indent + buf.trimEnd());
+  return lines;
+}
+const colors = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m"
+};
+class Logger {
+  previousLines = [];
+  showPrompt = true;
+  prompt;
+  errorPrompt;
+  constructor(options = {}) {
+    this.prompt = `${colors.bold}${options.promptColor ?? colors.brightGreen}> ${colors.reset}`;
+    this.errorPrompt = `${options.errorPromptColor ?? colors.brightRed}> ${colors.reset}`;
+  }
+  // ─── Utilities ───────────────────────────────────────────
+  visibleWidth(str) {
+    return [...str.replace(ANSI_FULL_REGEX, "")].length;
+  }
+  clearLine() {
+    process.stdout.write("\r\x1B[K");
+  }
+  writeLine(line, color = "") {
+    this.clearLine();
+    process.stdout.write(color + line + colors.reset);
+    if (this.visibleWidth(line) >= MAX_WIDTH) {
+      process.stdout.write("\n");
+    }
+  }
+  addLine(text, opts = {}) {
+    this.previousLines.push({
+      text,
+      isRaw: opts.isRaw,
+      hasPrompt: opts.hasPrompt ?? this.showPrompt
+    });
+    if (this.previousLines.length > 200) {
+      this.previousLines.splice(0, 100);
+    }
+  }
+  // ─── REFORMAT (RESTORED) ─────────────────────────────────
+  reformat(text, opts) {
+    const { width, align = "left", padChar = " " } = opts;
+    const normalized = text.replace(/\r?\n/g, " ").replace(/[\uFEFF\xA0\t]/g, " ").replace(/\s{2,}/g, " ").trim();
+    const lines = [];
+    let buf = "";
+    let vis = 0;
+    const tokens = normalized.split(
+      /(\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\)))/g
+    );
+    for (const token of tokens) {
+      if (ANSI_FULL_REGEX.test(token)) {
+        buf += token;
+        continue;
+      }
+      for (const ch of [...token]) {
+        if (vis >= width) {
+          lines.push(this.applyPadding(buf, vis, width, align, padChar));
+          buf = "";
+          vis = 0;
+        }
+        buf += ch;
+        vis++;
+      }
+    }
+    if (buf) {
+      lines.push(this.applyPadding(buf, vis, width, align, padChar));
+    }
+    return lines;
+  }
+  applyPadding(text, visible, width, align, padChar) {
+    const pad = Math.max(0, width - visible);
+    switch (align) {
+      case "right":
+        return padChar.repeat(pad) + text;
+      case "center": {
+        const left = Math.floor(pad / 2);
+        const right = pad - left;
+        return padChar.repeat(left) + text + padChar.repeat(right);
+      }
+      default:
+        return text + padChar.repeat(pad);
+    }
+  }
+  // ─── Printing ────────────────────────────────────────────
+  print(msg) {
+    const lines = wrapLine(
+      this.showPrompt ? this.prompt + msg : msg,
+      MAX_WIDTH,
+      0,
+      "word"
+    );
+    for (let i = 0; i < lines.length; i++) {
+      this.writeLine(lines[i]);
+      if (i < lines.length - 1) process.stdout.write("\n");
+      this.addLine(lines[i]);
+    }
+    this.showPrompt = false;
+    return true;
+  }
+  println(msg = "") {
+    if (msg) this.print(msg);
+    process.stdout.write("\n");
+    this.addLine("");
+    this.showPrompt = true;
+    return true;
+  }
+  printRaw(line) {
+    process.stdout.write(line);
+    this.addLine(line, { isRaw: true });
+    return true;
+  }
+  printlnRaw(line = "") {
+    this.printRaw(line);
+    process.stdout.write("\n");
+    this.addLine("", { isRaw: true });
+    return true;
+  }
+  error(msg) {
+    const lines = wrapLine(
+      this.showPrompt ? this.errorPrompt + msg : msg,
+      MAX_WIDTH,
+      0,
+      "word"
+    );
+    for (let i = 0; i < lines.length; i++) {
+      this.writeLine(lines[i], colors.brightRed);
+      if (i < lines.length - 1) process.stdout.write("\n");
+      this.addLine(lines[i]);
+    }
+    process.stdout.write("\n");
+    this.showPrompt = true;
+    return true;
+  }
+  // ─── History ─────────────────────────────────────────────
+  clearHistory() {
+    this.previousLines = [];
+  }
+  getHistory() {
+    return [...this.previousLines];
+  }
+}
+const logger = new Logger();
+class JasmineConsoleReporter {
+  print = (message) => process.stdout.write(message);
+  showColors = true;
+  specCount = 0;
+  executableSpecCount = 0;
+  failureCount = 0;
+  failedSpecs = [];
+  pendingSpecs = [];
+  alwaysListPendingSpecs = true;
+  ansi = {
+    green: "\x1B[32m",
+    red: "\x1B[31m",
+    yellow: "\x1B[33m",
+    none: "\x1B[0m"
+  };
+  failedSuites = [];
+  stackFilter = (stack) => stack;
+  randomSeedReproductionCmd(seed) {
+    return "jasmine --random=true --seed=" + seed;
+  }
+  /**
+   * Configures the reporter.
+   */
+  setOptions(options) {
+    if (options.print) {
+      this.print = options.print;
+    }
+    this.showColors = options.showColors || false;
+    if (options.stackFilter) {
+      this.stackFilter = options.stackFilter;
+    }
+    if (options.randomSeedReproductionCmd) {
+      this.randomSeedReproductionCmd = options.randomSeedReproductionCmd;
+    }
+    if (options.alwaysListPendingSpecs !== void 0) {
+      this.alwaysListPendingSpecs = options.alwaysListPendingSpecs;
+    }
+  }
+  jasmineStarted(options) {
+    this.specCount = 0;
+    this.executableSpecCount = 0;
+    this.failureCount = 0;
+    if (options?.order?.random) {
+      this.print("Randomized with seed " + options.order.seed);
+      this.printNewline();
+    }
+    this.print("Started");
+    this.printNewline();
+  }
+  jasmineDone(result) {
+    if (result.failedExpectations) {
+      this.failureCount += result.failedExpectations.length;
+    }
+    this.printNewline();
+    this.printNewline();
+    if (this.failedSpecs.length > 0) {
+      this.print("Failures:");
+    }
+    for (let i = 0; i < this.failedSpecs.length; i++) {
+      this.specFailureDetails(this.failedSpecs[i], i + 1);
+    }
+    for (let i = 0; i < this.failedSuites.length; i++) {
+      this.suiteFailureDetails(this.failedSuites[i]);
+    }
+    if (result.failedExpectations?.length > 0) {
+      this.suiteFailureDetails({
+        fullName: "top suite",
+        failedExpectations: result.failedExpectations
+      });
+    }
+    if (this.alwaysListPendingSpecs || result.overallStatus === "passed") {
+      if (this.pendingSpecs.length > 0) {
+        this.print("Pending:");
+      }
+      for (let i = 0; i < this.pendingSpecs.length; i++) {
+        this.pendingSpecDetails(this.pendingSpecs[i], i + 1);
+      }
+    }
+    if (this.specCount > 0) {
+      this.printNewline();
+      if (this.executableSpecCount !== this.specCount) {
+        this.print(
+          "Ran " + this.executableSpecCount + " of " + this.specCount + this.plural(" spec", this.specCount)
+        );
+        this.printNewline();
+      }
+      let specCounts = this.executableSpecCount + " " + this.plural("spec", this.executableSpecCount) + ", " + this.failureCount + " " + this.plural("failure", this.failureCount);
+      if (this.pendingSpecs.length) {
+        specCounts += ", " + this.pendingSpecs.length + " pending " + this.plural("spec", this.pendingSpecs.length);
+      }
+      this.print(specCounts);
+    } else {
+      this.print("No specs found");
+    }
+    this.printNewline();
+    const seconds = result ? result.totalTime / 1e3 : 0;
+    this.print("Finished in " + seconds + " " + this.plural("second", seconds));
+    this.printNewline();
+    if (result && result.overallStatus === "incomplete") {
+      this.print("Incomplete: " + result.incompleteReason);
+      this.printNewline();
+    }
+    if (result.order?.random) {
+      this.print("Randomized with seed " + result.order.seed);
+      this.print(" (" + this.randomSeedReproductionCmd(result.order.seed) + ")");
+      this.printNewline();
+    }
+  }
+  specDone(result) {
+    this.specCount++;
+    if (result.status == "pending") {
+      this.pendingSpecs.push(result);
+      this.executableSpecCount++;
+      this.print(this.colored("yellow", "*"));
+      return;
+    }
+    if (result.status == "passed") {
+      this.executableSpecCount++;
+      this.print(this.colored("green", "."));
+      return;
+    }
+    if (result.status == "failed") {
+      this.failureCount++;
+      this.failedSpecs.push(result);
+      this.executableSpecCount++;
+      this.print(this.colored("red", "F"));
+    }
+  }
+  suiteDone(result) {
+    if (result.failedExpectations && result.failedExpectations.length > 0) {
+      this.failureCount++;
+      this.failedSuites.push(result);
+    }
+  }
+  reporterCapabilities = { parallel: true };
+  printNewline() {
+    this.print("\n");
+  }
+  colored(color, str) {
+    return this.showColors ? this.ansi[color] + str + this.ansi.none : str;
+  }
+  plural(str, count) {
+    return count == 1 ? str : str + "s";
+  }
+  repeat(thing, times) {
+    return Array.from({ length: times }, () => thing);
+  }
+  indent(str, spaces) {
+    const lines = (str || "").split("\n");
+    return lines.map((line) => this.repeat(" ", spaces).join("") + line).join("\n");
+  }
+  specFailureDetails(result, failedSpecNumber) {
+    this.printNewline();
+    this.print(failedSpecNumber + ") ");
+    this.print(result.fullName);
+    this.printFailedExpectations(result);
+    if (result.debugLogs?.length) {
+      this.printNewline();
+      this.print(this.indent("Debug logs:", 2));
+      this.printNewline();
+      for (const entry of result.debugLogs) {
+        this.print(this.indent(`${entry.timestamp}ms: ${entry.message}`, 4));
+        this.printNewline();
+      }
+    }
+  }
+  suiteFailureDetails(result) {
+    this.printNewline();
+    this.print("Suite error: " + result.fullName);
+    this.printFailedExpectations(result);
+  }
+  printFailedExpectations(result) {
+    for (let i = 0; i < result.failedExpectations.length; i++) {
+      const failedExpectation = result.failedExpectations[i];
+      this.printNewline();
+      this.print(this.indent("Message:", 2));
+      this.printNewline();
+      this.print(this.colored("red", this.indent(failedExpectation.message, 4)));
+      this.printNewline();
+      this.print(this.indent("Stack:", 2));
+      this.printNewline();
+      this.print(this.indent(this.stackFilter(failedExpectation.stack), 4));
+    }
+    if (result.failedExpectations.length === 0 && Array.isArray(result.passedExpectations) && result.passedExpectations.length === 0) {
+      this.printNewline();
+      this.print(this.indent("Message:", 2));
+      this.printNewline();
+      this.print(this.colored("red", this.indent("Spec has no expectations", 4)));
+    }
+    this.printNewline();
+  }
+  pendingSpecDetails(result, pendingSpecNumber) {
+    this.printNewline();
+    this.printNewline();
+    this.print(pendingSpecNumber + ") ");
+    this.print(result.fullName);
+    this.printNewline();
+    let pendingReason = "No reason given";
+    if (result.pendingReason && result.pendingReason !== "") {
+      pendingReason = result.pendingReason;
+    }
+    this.print(this.indent(this.colored("yellow", pendingReason), 2));
+    this.printNewline();
+  }
+}
+class AwaitableJasmineConsoleReporter extends JasmineConsoleReporter {
+  resolveComplete;
+  complete;
+  constructor() {
+    super();
+    this.complete = new Promise((resolve) => {
+      this.resolveComplete = resolve;
+    });
+  }
+  jasmineDone(result) {
+    super.jasmineDone(result);
+    this.resolveComplete?.(result);
+  }
+}
+class JSONCleaner {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      removeComments: options.removeComments !== false,
+      removeTrailingCommas: options.removeTrailingCommas !== false,
+      normalizeWhitespace: options.normalizeWhitespace === true,
+      allowSingleQuotes: options.allowSingleQuotes === true,
+      preserveNewlines: options.preserveNewlines !== false,
+      strict: options.strict === true
+    };
+  }
+  /**
+   * Clean JSON string by removing comments and fixing common issues
+   */
+  clean(jsonString) {
+    if (typeof jsonString !== "string") {
+      throw new Error("Input must be a string");
+    }
+    let result = jsonString;
+    if (this.options.removeComments) {
+      result = this.stripComments(result);
+    }
+    if (this.options.removeTrailingCommas) {
+      result = this.removeTrailingCommas(result);
+    }
+    if (this.options.allowSingleQuotes) {
+      result = this.normalizeSingleQuotes(result);
+    }
+    if (this.options.normalizeWhitespace) {
+      result = this.normalizeWhitespace(result);
+    }
+    if (this.options.strict) {
+      try {
+        JSON.parse(result);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON after cleaning: ${message}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * Strip single-line and multi-line comments
+   * More robust than simple regex - handles edge cases
+   */
+  stripComments(str) {
+    let result = "";
+    let i = 0;
+    const state = {
+      inString: false,
+      stringChar: null,
+      escapeNext: false
+    };
+    while (i < str.length) {
+      const char = str[i];
+      const nextChar = str[i + 1];
+      if (state.escapeNext) {
+        result += char;
+        state.escapeNext = false;
+        i++;
+        continue;
+      }
+      if (char === "\\" && state.inString) {
+        result += char;
+        state.escapeNext = true;
+        i++;
+        continue;
+      }
+      if ((char === '"' || char === "'") && !state.escapeNext) {
+        if (!state.inString) {
+          state.inString = true;
+          state.stringChar = char;
+          result += char;
+        } else if (char === state.stringChar) {
+          state.inString = false;
+          state.stringChar = null;
+          result += char;
+        } else {
+          result += char;
+        }
+        i++;
+        continue;
+      }
+      if (!state.inString) {
+        if (char === "/" && nextChar === "/") {
+          i += 2;
+          while (i < str.length && str[i] !== "\n" && str[i] !== "\r") {
+            i++;
+          }
+          if (i < str.length && this.options.preserveNewlines) {
+            result += str[i];
+          }
+          i++;
+          continue;
+        }
+        if (char === "/" && nextChar === "*") {
+          i += 2;
+          let foundEnd = false;
+          let newlineCount = 0;
+          while (i < str.length - 1) {
+            if (str[i] === "\n") newlineCount++;
+            if (str[i] === "*" && str[i + 1] === "/") {
+              i += 2;
+              foundEnd = true;
+              break;
+            }
+            i++;
+          }
+          if (!foundEnd) {
+            throw new Error("Unclosed multi-line comment");
+          }
+          if (this.options.preserveNewlines && newlineCount > 0) {
+            result += "\n".repeat(Math.min(newlineCount, 2));
+          }
+          continue;
+        }
+      }
+      result += char;
+      i++;
+    }
+    if (state.inString) {
+      throw new Error("Unclosed string in JSON");
+    }
+    return result;
+  }
+  /**
+   * Remove trailing commas before closing brackets/braces
+   */
+  removeTrailingCommas(str) {
+    let result = "";
+    let i = 0;
+    const state = {
+      inString: false,
+      stringChar: null,
+      escapeNext: false
+    };
+    while (i < str.length) {
+      const char = str[i];
+      if (state.escapeNext) {
+        result += char;
+        state.escapeNext = false;
+        i++;
+        continue;
+      }
+      if (char === "\\" && state.inString) {
+        result += char;
+        state.escapeNext = true;
+        i++;
+        continue;
+      }
+      if ((char === '"' || char === "'") && !state.escapeNext) {
+        if (!state.inString) {
+          state.inString = true;
+          state.stringChar = char;
+        } else if (char === state.stringChar) {
+          state.inString = false;
+          state.stringChar = null;
+        }
+        result += char;
+        i++;
+        continue;
+      }
+      if (!state.inString && char === ",") {
+        let j = i + 1;
+        while (j < str.length && /\s/.test(str[j])) {
+          j++;
+        }
+        if (j < str.length && (str[j] === "]" || str[j] === "}")) {
+          i++;
+          continue;
+        }
+      }
+      result += char;
+      i++;
+    }
+    return result;
+  }
+  /**
+   * Convert single quotes to double quotes (outside of strings)
+   */
+  normalizeSingleQuotes(str) {
+    let result = "";
+    let i = 0;
+    const state = {
+      inString: false,
+      stringChar: null,
+      escapeNext: false
+    };
+    while (i < str.length) {
+      const char = str[i];
+      if (state.escapeNext) {
+        result += char;
+        state.escapeNext = false;
+        i++;
+        continue;
+      }
+      if (char === "\\" && state.inString) {
+        result += char;
+        state.escapeNext = true;
+        i++;
+        continue;
+      }
+      if ((char === '"' || char === "'") && !state.escapeNext) {
+        if (!state.inString) {
+          state.inString = true;
+          state.stringChar = char;
+          result += '"';
+        } else if (char === state.stringChar) {
+          state.inString = false;
+          state.stringChar = null;
+          result += '"';
+        } else {
+          if (char === '"') {
+            result += '\\"';
+          } else {
+            result += char;
+          }
+        }
+        i++;
+        continue;
+      }
+      result += char;
+      i++;
+    }
+    return result;
+  }
+  /**
+   * Normalize whitespace
+   */
+  normalizeWhitespace(str) {
+    return str.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).join("\n");
+  }
+  /**
+   * Parse JSON string with automatic cleaning
+   */
+  parse(jsonString) {
+    const cleaned = this.clean(jsonString);
+    return JSON.parse(cleaned);
+  }
+  /**
+   * Read and clean JSON file
+   */
+  readFile(filePath, encoding = "utf8") {
+    const content = fs.readFileSync(filePath, encoding);
+    return this.clean(content);
+  }
+  /**
+   * Read, clean, and parse JSON file
+   */
+  parseFile(filePath, encoding = "utf8") {
+    const cleaned = this.readFile(filePath, encoding);
+    return JSON.parse(cleaned);
+  }
+  /**
+   * Clean and write JSON file
+   */
+  writeFile(filePath, jsonString, encoding = "utf8") {
+    const cleaned = this.clean(jsonString);
+    fs.writeFileSync(filePath, cleaned, encoding);
+  }
+  /**
+   * Clean and prettify JSON file
+   */
+  prettifyFile(inputPath, outputPath = null, indent = 2) {
+    const parsed = this.parseFile(inputPath);
+    const prettified = JSON.stringify(parsed, null, indent);
+    const targetPath = outputPath || inputPath;
+    fs.writeFileSync(targetPath, prettified, "utf8");
+  }
+}
+const norm = (p) => p.replace(/\\/g, "/");
+const packageRoot = norm(path.resolve(__dirname, ".."));
+const packageRequire = createRequire(path.join(packageRoot, "package.json"));
+const vscodeLaunchConfigName = "Debug current spec (jasmine)";
+function getRuntimeEnv() {
+  const runtimeProcess = globalThis.process;
+  return runtimeProcess?.env ?? {};
+}
+function isRunningInVsCode() {
+  const env = getRuntimeEnv();
+  return env.TERM_PROGRAM === "vscode" || typeof env.VSCODE_PID === "string" || typeof env.VSCODE_CWD === "string" || typeof env.VSCODE_INSPECTOR_OPTIONS === "string";
+}
+function printHelp() {
+  logger.println("jasmine: run a single Jasmine spec in Node");
+  logger.println("");
+  logger.println("Usage:");
+  logger.println("  npx jasmine --spec <path-to-spec>");
+  logger.println("  npx jasmine init");
+  logger.println("");
+  logger.println("Commands:");
+  logger.println("  init                Create/update .vscode/launch.json (VS Code debug; requires VS Code)");
+  logger.println("");
+  logger.println("Options:");
+  logger.println("  --spec <path>        Path to a single spec file");
+  logger.println("  --random             Randomize spec order");
+  logger.println("  --seed <number>      Seed used for randomization");
+  logger.println("  --stop-on-fail       Stop on first expectation failure");
+  logger.println("  --help               Show this help");
+  logger.println("");
+  logger.println("TypeScript + tsconfig paths (recommended):");
+  logger.println(
+    "  node --loader @epikodelabs/testify/esm-loader.mjs ./node_modules/@epikodelabs/testify/bin/jasmine --spec <file>"
+  );
+  logger.println("");
+  logger.println("VS Code debug config name:");
+  logger.println(`  ${vscodeLaunchConfigName}`);
+}
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const get = (flag) => {
+    const index = args.indexOf(flag);
+    if (index === -1) return void 0;
+    return args[index + 1];
+  };
+  const help = args.includes("--help") || args.includes("-h");
+  const command = args[0];
+  const initLaunchConfig = args.includes("--init-launch-config") || command === "init";
+  const specRaw = get("--spec");
+  if (help) {
+    return {
+      spec: specRaw ? norm(path.resolve(process.cwd(), specRaw)) : "",
+      random: args.includes("--random"),
+      stopOnFail: args.includes("--stop-on-fail"),
+      seed: get("--seed") ? Number(get("--seed")) : void 0,
+      help: true,
+      initLaunchConfig
+    };
+  }
+  if (command && !command.startsWith("-") && command !== "init") {
+    logger.error(`ERROR: Unknown command: ${command}`);
+    logger.println("");
+    printHelp();
+    process.exit(1);
+  }
+  if (initLaunchConfig) {
+    return {
+      spec: specRaw ? norm(path.resolve(process.cwd(), specRaw)) : "",
+      random: args.includes("--random"),
+      stopOnFail: args.includes("--stop-on-fail"),
+      seed: get("--seed") ? Number(get("--seed")) : void 0,
+      help: false,
+      initLaunchConfig: true
+    };
+  }
+  if (!specRaw) {
+    logger.error("ERROR: Missing required --spec <path>");
+    logger.println("");
+    printHelp();
+    process.exit(1);
+  }
+  const spec = norm(path.resolve(process.cwd(), specRaw));
+  if (!fs__default.existsSync(spec)) {
+    logger.error(`ERROR: Spec file not found: ${spec}`);
+    process.exit(1);
+  }
+  const seedRaw = get("--seed");
+  return {
+    spec,
+    random: args.includes("--random"),
+    stopOnFail: args.includes("--stop-on-fail"),
+    seed: seedRaw ? Number(seedRaw) : void 0,
+    help: false,
+    initLaunchConfig: false
+  };
+}
+function normalizeCliArgs(args) {
+  const normalized = [...args];
+  for (let i = 0; i < normalized.length; i += 1) {
+    if (normalized[i] === "--spec" && typeof normalized[i + 1] === "string") {
+      normalized[i + 1] = norm(normalized[i + 1]);
+      i += 1;
+    }
+  }
+  return normalized;
+}
+function isTypeScriptLike(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ext === ".ts" || ext === ".tsx" || ext === ".mts" || ext === ".cts";
+}
+function hasEsmLoader() {
+  const fromNodeOptions = (getRuntimeEnv().NODE_OPTIONS ?? "").split(/\s+/g).filter(Boolean);
+  const argv = [...process.execArgv, ...fromNodeOptions];
+  return argv.includes("--loader") || argv.some((a) => a.startsWith("--loader="));
+}
+function findNearestTsconfig(startDir) {
+  let current = norm(path.resolve(startDir));
+  while (true) {
+    const candidate = norm(path.join(current, "tsconfig.json"));
+    if (fs__default.existsSync(candidate)) return candidate;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function getDefaultVsCodeLaunchConfiguration() {
+  return {
+    type: "node",
+    request: "launch",
+    name: vscodeLaunchConfigName,
+    runtimeExecutable: "node",
+    runtimeArgs: ["--loader", "@epikodelabs/testify/esm-loader.mjs", "--enable-source-maps"],
+    program: "${workspaceFolder}/node_modules/@epikodelabs/testify/bin/jasmine",
+    args: ["--spec", "${file}"],
+    env: {
+      TS_NODE_PROJECT: "${workspaceFolder}/tsconfig.json"
+    },
+    cwd: "${workspaceFolder}",
+    console: "integratedTerminal",
+    skipFiles: ["<node_internals>/**"]
+  };
+}
+function initVsCodeLaunchConfig() {
+  const vscodeDir = norm(path.resolve(process.cwd(), ".vscode"));
+  const launchJsonPath = norm(path.join(vscodeDir, "launch.json"));
+  const config = getDefaultVsCodeLaunchConfiguration();
+  fs__default.mkdirSync(vscodeDir, { recursive: true });
+  if (!fs__default.existsSync(launchJsonPath)) {
+    const launchJson = { version: "0.2.0", configurations: [config] };
+    fs__default.writeFileSync(launchJsonPath, `${JSON.stringify(launchJson, null, 2)}
+`);
+    logger.println(`Created VS Code launch config at ${launchJsonPath}`);
+    logger.println(`Added configuration: ${vscodeLaunchConfigName}`);
+    return;
+  }
+  const raw = fs__default.readFileSync(launchJsonPath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    try {
+      parsed = new JSONCleaner().parse(raw);
+    } catch (error) {
+      logger.error(`ERROR: Failed to parse existing VS Code launch config: ${launchJsonPath}`);
+      logger.error(String(error));
+      logger.println("");
+      logger.println("Add this configuration manually:");
+      logger.println(`${JSON.stringify(getDefaultVsCodeLaunchConfiguration(), null, 2)}`);
+      process.exit(1);
+    }
+  }
+  if (!parsed || typeof parsed !== "object") parsed = {};
+  if (!Array.isArray(parsed.configurations)) parsed.configurations = [];
+  const programSuffix = "/bin/jasmine";
+  const alreadyHasConfig = parsed.configurations.some((c) => {
+    if (!c || typeof c !== "object") return false;
+    if (c.name === vscodeLaunchConfigName) return true;
+    const program = typeof c.program === "string" ? c.program.replace(/\\/g, "/") : "";
+    const args = Array.isArray(c.args) ? c.args : [];
+    return program.endsWith(programSuffix) && args.includes("--spec");
+  });
+  if (alreadyHasConfig) {
+    logger.println(`VS Code launch config already contains: ${vscodeLaunchConfigName}`);
+    return;
+  }
+  parsed.version ??= "0.2.0";
+  parsed.configurations.unshift(config);
+  fs__default.writeFileSync(launchJsonPath, `${JSON.stringify(parsed, null, 2)}
+`);
+  logger.println(`Updated VS Code launch config at ${launchJsonPath}`);
+  logger.println(`Added configuration: ${vscodeLaunchConfigName}`);
+}
+async function respawnWithLoader(args) {
+  const { spawn } = await __vitePreload(async () => {
+    const { spawn: spawn2 } = await import("child_process");
+    return { spawn: spawn2 };
+  }, true ? [] : void 0);
+  const tsconfig = findNearestTsconfig(path.dirname(args.spec));
+  const env = { ...getRuntimeEnv() };
+  if (tsconfig) env.TS_NODE_PROJECT = tsconfig;
+  env.TS_NODE_TRANSPILE_ONLY ??= "true";
+  const loaderPath = norm(path.join(packageRoot, "esm-loader.mjs"));
+  const loaderSpecifier = fs__default.existsSync(loaderPath) ? pathToFileURL(loaderPath).href : "@epikodelabs/testify/esm-loader.mjs";
+  const child = spawn(
+    process.execPath,
+    [
+      "--loader",
+      loaderSpecifier,
+      "--enable-source-maps",
+      process.argv[1],
+      ...normalizeCliArgs(process.argv.slice(2))
+    ],
+    { stdio: "inherit", env, cwd: process.cwd() }
+  );
+  child.on("exit", (code) => process.exit(code ?? 1));
+  while (true) {
+    await new Promise((r) => setTimeout(r, 1e6));
+  }
+}
+async function loadJasmine() {
+  const jasmineCorePath = norm(packageRequire.resolve("jasmine-core/lib/jasmine-core/jasmine.js"));
+  const jasmineCore = await import(pathToFileURL(jasmineCorePath).href);
+  const jasmineRequire = jasmineCore.default;
+  const jasmineInstance = jasmineRequire.core(jasmineRequire);
+  const jasmineEnv = jasmineInstance.getEnv();
+  Object.assign(globalThis, jasmineRequire.interface(jasmineInstance, jasmineEnv));
+  globalThis.jasmine = {
+    ...globalThis.jasmine ?? {},
+    ...jasmineInstance
+  };
+  return { jasmineEnv, jasmineInstance };
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (args.initLaunchConfig) {
+    if (!isRunningInVsCode()) {
+      logger.error("ERROR: `npx jasmine init` is only supported when run from VS Code.");
+      logger.println("");
+      logger.println("Open VS Code, then run this from the integrated terminal (Terminal -> New Terminal).");
+      process.exit(1);
+    }
+    initVsCodeLaunchConfig();
+    process.exit(0);
+  }
+  if (isTypeScriptLike(args.spec) && !hasEsmLoader() && !process.execArgv.join(" ").includes("--inspect")) {
+    await respawnWithLoader(args);
+  }
+  const { jasmineEnv } = await loadJasmine();
+  process.on("unhandledRejection", (error) => {
+    logger.error(`ERROR: Unhandled rejection: ${error}`);
+    process.exit(1);
+  });
+  process.on("uncaughtException", (error) => {
+    logger.error(`ERROR: Uncaught exception: ${error}`);
+    process.exit(1);
+  });
+  jasmineEnv.configure({
+    random: args.random,
+    stopSpecOnExpectationFailure: args.stopOnFail,
+    seed: args.seed
+  });
+  const reporter = new AwaitableJasmineConsoleReporter();
+  jasmineEnv.addReporter(reporter);
+  await import(pathToFileURL(args.spec).href);
+  await jasmineEnv.execute();
+  const exitCode = (await reporter.complete)?.overallStatus === "passed" ? 0 : 1;
+  process.exit(exitCode);
+}
+main().catch((error) => {
+  logger.error(`ERROR: Failed to run jasmine: ${error.stack ?? error}`);
+  process.exit(1);
+});