// src/lib/reporting/runWithEnvelope.ts
import { performance as performance2 } from "node:perf_hooks";

// src/lib/reporting/xyReporter.ts
import { performance } from "node:perf_hooks";
var reporterState = {
  currentCommand: "unknown",
  isEnvelopeEmitted: false,
  isJsonModeEnabled: false,
  isStrictModeEnabled: false,
  originalStdoutWrite: void 0,
  startTime: 0
};
function isJsonMode() {
  return reporterState.isJsonModeEnabled;
}
function setJsonMode(isEnabled) {
  if (reporterState.isJsonModeEnabled === isEnabled) return;
  reporterState.isJsonModeEnabled = isEnabled;
  if (isEnabled && !reporterState.originalStdoutWrite) {
    reporterState.originalStdoutWrite = process.stdout.write.bind(process.stdout);
    const stderrWrite = process.stderr.write.bind(process.stderr);
    process.stdout.write = stderrWrite;
    process.on("exit", emitFallbackEnvelope);
  }
}
function isStrictMode() {
  return reporterState.isStrictModeEnabled || process.env.XY_STRICT === "1";
}
function setStrictMode(isEnabled) {
  reporterState.isStrictModeEnabled = isEnabled;
  if (isEnabled) {
    process.env.XY_STRICT = "1";
  }
}
function setCurrentCommand(name) {
  reporterState.currentCommand = name;
  reporterState.startTime = performance.now();
  reporterState.isEnvelopeEmitted = false;
}
function emitJson(envelope) {
  if (reporterState.isEnvelopeEmitted) return;
  reporterState.isEnvelopeEmitted = true;
  const json = JSON.stringify(envelope) + "\n";
  if (reporterState.originalStdoutWrite) {
    reporterState.originalStdoutWrite(json);
  } else {
    process.stdout.write(json);
  }
}
function emitFallbackEnvelope() {
  if (reporterState.isEnvelopeEmitted) return;
  const raw = process.exitCode ?? 0;
  const code = typeof raw === "number" ? raw : Number(raw) || 0;
  emitJson({
    command: reporterState.currentCommand,
    durationMs: Math.round(performance.now() - reporterState.startTime),
    errorCount: code === 0 ? 0 : 1,
    exitCode: code,
    schemaVersion: 1,
    success: code === 0,
    warningCount: 0
  });
}
function xyLog(...args) {
  if (reporterState.isJsonModeEnabled) {
    process.stderr.write(args.map((arg) => typeof arg === "string" ? arg : String(arg)).join(" ") + "\n");
  } else {
    console.log(...args);
  }
}
function resetReporterForTesting() {
  if (reporterState.originalStdoutWrite) {
    process.stdout.write = reporterState.originalStdoutWrite;
    reporterState.originalStdoutWrite = void 0;
  }
  reporterState.isJsonModeEnabled = false;
  reporterState.isEnvelopeEmitted = false;
  reporterState.currentCommand = "unknown";
  reporterState.startTime = 0;
}

// src/lib/reporting/runWithEnvelope.ts
async function runWithEnvelope(command, action) {
  setCurrentCommand(command);
  const start = performance2.now();
  let exitCode;
  let envelope;
  try {
    const ret = await action();
    if (typeof ret === "number") {
      exitCode = ret;
    } else {
      exitCode = ret.exitCode;
      envelope = ret.envelope;
    }
  } catch (ex) {
    exitCode = 1;
    const message = ex instanceof Error ? ex.message : String(ex);
    envelope = {
      errorCount: 1,
      errors: [{ message }]
    };
    if (!isJsonMode()) {
      console.error(message);
    }
  }
  if (isJsonMode()) {
    emitJson({
      command,
      data: envelope?.data,
      durationMs: Math.round(performance2.now() - start),
      errorCount: envelope?.errorCount ?? (exitCode === 0 ? 0 : 1),
      errors: envelope?.errors,
      exitCode,
      schemaVersion: 1,
      success: exitCode === 0,
      warningCount: envelope?.warningCount ?? 0,
      warnings: envelope?.warnings
    });
  }
  return exitCode;
}
async function withEnvelope(command, action) {
  process.exitCode = await runWithEnvelope(command, action);
}
export {
  emitJson,
  isJsonMode,
  isStrictMode,
  resetReporterForTesting,
  runWithEnvelope,
  setCurrentCommand,
  setJsonMode,
  setStrictMode,
  withEnvelope,
  xyLog
};
//# sourceMappingURL=index.mjs.map
