brass-runtime 1.16.0 → 1.17.0

package/dist/perf/cli.mjs

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+import {
+  HTTP_PROFILE_VARIANTS,
+  comparePerfToBaseline,
+  createPerfHistoryEntry,
+  formatHttpMemoryLabReport,
+  formatPerfBaselineComparison,
+  formatPerformanceReport,
+  formatRuntimeAbReport,
+  formatRuntimeSoakReport,
+  loadPerfBaseline,
+  profileHttpMemoryLab,
+  profileRuntimeAb,
+  profileRuntimeSoak,
+  runBrassPerformanceProfile,
+  savePerfBaseline,
+  writePerfHistoryEntry
+} from "../chunk-6RY2FFN4.mjs";
+import "../chunk-EOC4UHBS.mjs";
+import "../chunk-7CMJS3QE.mjs";
+import "../chunk-5VRJNBLZ.mjs";
+import "../chunk-MOO4L7F4.mjs";
+import "../chunk-FHQGHPMO.mjs";
+import "../chunk-B5JD23U7.mjs";
+import "../chunk-2HQTDLHF.mjs";
+import "../chunk-A2OM6NEH.mjs";
+import "../chunk-SK7UZRNI.mjs";
+import "../chunk-4P2HHGAX.mjs";
+import "../chunk-EJ6BPYVR.mjs";
+import "../chunk-PWC3RBQE.mjs";
+import "../chunk-GYM3LLGS.mjs";
+import "../chunk-36I3M4UC.mjs";
+import "../chunk-DNFJLJMW.mjs";
+import "../chunk-Y6FXYEAI.mjs";
+
+// src/perf/cli.ts
+async function main(argv) {
+  const cli = parseArgs(argv);
+  if (cli.profile === "runtime-ab") {
+    const report2 = await profileRuntimeAb(cli.runtimeAb);
+    await printReport(cli, report2, formatRuntimeAbReport(report2));
+    return;
+  }
+  if (cli.profile === "runtime-soak") {
+    const report2 = await profileRuntimeSoak(cli.runtimeSoak);
+    await printReport(cli, report2, formatRuntimeSoakReport(report2));
+    return;
+  }
+  if (cli.profile === "http-memory") {
+    const report2 = await profileHttpMemoryLab(cli.httpMemory);
+    await printReport(cli, report2, formatHttpMemoryLabReport(report2));
+    return;
+  }
+  const report = await runBrassPerformanceProfile(cli.options);
+  await printReport(cli, report, formatPerformanceReport(report));
+}
+function parseArgs(argv) {
+  let json = envBool("BRASS_PERF_JSON", false);
+  let profile = envProfile("BRASS_PERF_PROFILE", "all");
+  let calls = envInt("BRASS_PERF_CALLS", void 0);
+  let concurrency = envInt("BRASS_PERF_CONCURRENCY", void 0);
+  let delayMs = envInt("BRASS_PERF_DELAY_MS", void 0);
+  let warmupCalls = envInt("BRASS_PERF_WARMUP_CALLS", void 0);
+  let timeoutMs = envInt("BRASS_PERF_TIMEOUT_MS", void 0);
+  let statsSampleMs = envInt("BRASS_PERF_STATS_SAMPLE_MS", void 0);
+  let runtimeIterations = envInt("BRASS_PERF_RUNTIME_ITERATIONS", void 0);
+  let runtimeChainDepth = envInt("BRASS_PERF_RUNTIME_CHAIN_DEPTH", void 0);
+  let runtimeVariant = envRuntimeVariant("BRASS_PERF_RUNTIME_VARIANT");
+  let baseline = envRuntimeVariant("BRASS_PERF_BASELINE");
+  let candidate = envRuntimeVariant("BRASS_PERF_CANDIDATE");
+  let rounds = envInt("BRASS_PERF_ROUNDS", void 0);
+  let forceGc = envBool("BRASS_PERF_FORCE_GC", false);
+  let variants = envVariants("BRASS_PERF_VARIANTS");
+  let recordHistory = envBool("BRASS_PERF_RECORD_HISTORY", false);
+  let historyDir = envString("BRASS_PERF_HISTORY_DIR");
+  let historyMaxEntries = envInt("BRASS_PERF_HISTORY_MAX_ENTRIES", void 0);
+  let saveBaseline = envString("BRASS_PERF_SAVE_BASELINE");
+  let compareBaseline = envString("BRASS_PERF_COMPARE_BASELINE");
+  let failOnBaselineRegression = envBool("BRASS_PERF_FAIL_ON_BASELINE_REGRESSION", false);
+  let baselineMaxRegressionPercent = envNumber("BRASS_PERF_BASELINE_MAX_REGRESSION_PERCENT");
+  let baselineMaxHeapRegressionPercent = envNumber("BRASS_PERF_BASELINE_MAX_HEAP_REGRESSION_PERCENT");
+  let baselineWarnAtRatio = envNumber("BRASS_PERF_BASELINE_WARN_AT_RATIO");
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--json":
+        json = true;
+        break;
+      case "--profile":
+        profile = parseProfile(readValue(argv, ++i, arg));
+        break;
+      case "--calls":
+        calls = parsePositive(readValue(argv, ++i, arg), arg);
+        break;
+      case "--concurrency":
+        concurrency = parsePositive(readValue(argv, ++i, arg), arg);
+        break;
+      case "--delay-ms":
+        delayMs = parseNonNegative(readValue(argv, ++i, arg), arg);
+        break;
+      case "--warmup":
+      case "--warmup-calls":
+        warmupCalls = parseNonNegative(readValue(argv, ++i, arg), arg);
+        break;
+      case "--timeout-ms":
+        timeoutMs = parsePositive(readValue(argv, ++i, arg), arg);
+        break;
+      case "--stats-sample-ms":
+        statsSampleMs = parsePositive(readValue(argv, ++i, arg), arg);
+        break;
+      case "--runtime-iterations":
+        runtimeIterations = parsePositive(readValue(argv, ++i, arg), arg);
+        break;
+      case "--runtime-chain-depth":
+        runtimeChainDepth = parsePositive(readValue(argv, ++i, arg), arg);
+        break;
+      case "--runtime-variant":
+        runtimeVariant = parseRuntimeVariant(readValue(argv, ++i, arg));
+        break;
+      case "--baseline":
+        baseline = parseRuntimeVariant(readValue(argv, ++i, arg));
+        break;
+      case "--candidate":
+        candidate = parseRuntimeVariant(readValue(argv, ++i, arg));
+        break;
+      case "--rounds":
+        rounds = parsePositive(readValue(argv, ++i, arg), arg);
+        break;
+      case "--variants":
+        variants = parseVariants(readValue(argv, ++i, arg));
+        break;
+      case "--force-gc":
+        forceGc = true;
+        break;
+      case "--no-gc":
+        forceGc = false;
+        break;
+      case "--no-http":
+        profile = "runtime";
+        break;
+      case "--no-runtime":
+        profile = "http";
+        break;
+      case "--record-history":
+        recordHistory = true;
+        break;
+      case "--history-dir":
+        historyDir = readValue(argv, ++i, arg);
+        break;
+      case "--history-max-entries":
+        historyMaxEntries = parsePositive(readValue(argv, ++i, arg), arg);
+        break;
+      case "--save-baseline":
+        saveBaseline = readValue(argv, ++i, arg);
+        break;
+      case "--compare-baseline":
+        compareBaseline = readValue(argv, ++i, arg);
+        break;
+      case "--fail-on-baseline-regression":
+        failOnBaselineRegression = true;
+        break;
+      case "--baseline-max-regression-percent":
+        baselineMaxRegressionPercent = parseNonNegativeNumber(readValue(argv, ++i, arg), arg);
+        break;
+      case "--baseline-max-heap-regression-percent":
+        baselineMaxHeapRegressionPercent = parseNonNegativeNumber(readValue(argv, ++i, arg), arg);
+        break;
+      case "--baseline-warn-at-ratio":
+        baselineWarnAtRatio = parseNonNegativeNumber(readValue(argv, ++i, arg), arg);
+        break;
+      case "--help":
+      case "-h":
+        printHelp();
+        process.exit(0);
+      default:
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return {
+    json,
+    profile,
+    options: {
+      runtime: profile === "http" ? false : {
+        ...runtimeIterations !== void 0 ? { iterations: runtimeIterations } : {},
+        ...runtimeChainDepth !== void 0 ? { chainDepth: runtimeChainDepth } : {},
+        ...runtimeVariant !== void 0 ? { variant: runtimeVariant } : {}
+      },
+      http: profile === "runtime" ? false : {
+        ...calls !== void 0 ? { calls } : {},
+        ...concurrency !== void 0 ? { concurrency } : {},
+        ...delayMs !== void 0 ? { delayMs } : {},
+        ...warmupCalls !== void 0 ? { warmupCalls } : {},
+        ...timeoutMs !== void 0 ? { timeoutMs } : {},
+        ...statsSampleMs !== void 0 ? { statsSampleMs } : {},
+        ...variants !== void 0 ? { variants } : {},
+        forceGc
+      },
+      memory: { forceGc }
+    },
+    runtimeAb: {
+      baseline,
+      candidate,
+      runtime: {
+        ...runtimeIterations !== void 0 ? { iterations: runtimeIterations } : {},
+        ...runtimeChainDepth !== void 0 ? { chainDepth: runtimeChainDepth } : {}
+      },
+      forceGc
+    },
+    runtimeSoak: {
+      rounds,
+      variant: runtimeVariant,
+      runtime: {
+        ...runtimeIterations !== void 0 ? { iterations: runtimeIterations } : {},
+        ...runtimeChainDepth !== void 0 ? { chainDepth: runtimeChainDepth } : {}
+      },
+      forceGc
+    },
+    httpMemory: {
+      ...calls !== void 0 ? { calls } : {},
+      ...concurrency !== void 0 ? { concurrency } : {},
+      ...delayMs !== void 0 ? { delayMs } : {},
+      ...warmupCalls !== void 0 ? { warmupCalls } : {},
+      ...timeoutMs !== void 0 ? { timeoutMs } : {},
+      ...statsSampleMs !== void 0 ? { statsSampleMs } : {},
+      ...variants !== void 0 ? { variants } : {},
+      rounds,
+      forceGc
+    },
+    history: {
+      recordHistory,
+      ...historyDir !== void 0 ? { historyDir } : {},
+      ...historyMaxEntries !== void 0 ? { maxEntries: historyMaxEntries } : {},
+      ...saveBaseline !== void 0 ? { saveBaseline } : {},
+      ...compareBaseline !== void 0 ? { compareBaseline } : {},
+      failOnBaselineRegression,
+      thresholds: {
+        ...baselineMaxRegressionPercent !== void 0 ? { maxRegressionPercent: baselineMaxRegressionPercent } : {},
+        ...baselineMaxHeapRegressionPercent !== void 0 ? { maxHeapRegressionPercent: baselineMaxHeapRegressionPercent } : {},
+        ...baselineWarnAtRatio !== void 0 ? { warnAtRatio: baselineWarnAtRatio } : {}
+      }
+    }
+  };
+}
+function printHelp() {
+  console.log([
+    "Usage: npm run perf -- [options]",
+    "",
+    "Options:",
+    "  --profile all|runtime|http|runtime-ab|runtime-soak|http-memory",
+    "  --json",
+    "  --calls N",
+    "  --concurrency N",
+    "  --delay-ms N",
+    "  --warmup N",
+    "  --variants node-http-text,default-json,default-json-observed",
+    "  --runtime-iterations N",
+    "  --runtime-chain-depth N",
+    "  --runtime-variant default|fiber-only|active-hooks|recorder|wide-scheduler",
+    "  --baseline default|fiber-only|active-hooks|recorder|wide-scheduler",
+    "  --candidate default|fiber-only|active-hooks|recorder|wide-scheduler",
+    "  --rounds N",
+    "  --force-gc",
+    "  --no-gc",
+    "  --record-history",
+    "  --history-dir PATH",
+    "  --history-max-entries N",
+    "  --save-baseline NAME",
+    "  --compare-baseline NAME",
+    "  --baseline-max-regression-percent N",
+    "  --baseline-max-heap-regression-percent N",
+    "  --baseline-warn-at-ratio N",
+    "  --fail-on-baseline-regression"
+  ].join("\n"));
+}
+async function printReport(cli, report, textReport) {
+  const history = await maybeHandleHistory(cli, report);
+  if (cli.json) {
+    console.log(JSON.stringify(history ? { report, history } : report, null, 2));
+  } else {
+    console.log(history ? `${textReport}
+
+${formatCliHistory(history)}` : textReport);
+  }
+  if (history?.comparison && !history.comparison.passed && cli.history.failOnBaselineRegression) {
+    process.exitCode = 1;
+  }
+}
+async function maybeHandleHistory(cli, report) {
+  const config = cli.history;
+  if (!config.recordHistory && !config.saveBaseline && !config.compareBaseline) return void 0;
+  const storeOptions = {
+    ...config.historyDir !== void 0 ? { directory: config.historyDir } : {},
+    ...config.maxEntries !== void 0 ? { maxEntries: config.maxEntries } : {},
+    metadata: {
+      cliProfile: cli.profile
+    }
+  };
+  const entry = createPerfHistoryEntry(cli.profile, report, storeOptions);
+  const historyPath = config.recordHistory ? await writePerfHistoryEntry(entry, storeOptions) : void 0;
+  const savedBaseline = config.saveBaseline ? await savePerfBaseline(config.saveBaseline, entry, storeOptions) : void 0;
+  const loadedBaseline = config.compareBaseline ? await loadPerfBaseline(config.compareBaseline, storeOptions) : void 0;
+  if (config.compareBaseline && !loadedBaseline) {
+    throw new Error(`Perf baseline '${config.compareBaseline}' was not found`);
+  }
+  const comparison = loadedBaseline ? comparePerfToBaseline(entry, loadedBaseline, config.thresholds) : void 0;
+  return Object.freeze({
+    entry,
+    ...historyPath !== void 0 ? { historyPath } : {},
+    ...savedBaseline !== void 0 ? { savedBaselinePath: savedBaseline.path } : {},
+    ...comparison !== void 0 ? { comparison } : {}
+  });
+}
+function formatCliHistory(history) {
+  const lines = [];
+  lines.push("Performance history");
+  if (history.historyPath) lines.push(`- recorded: ${history.historyPath}`);
+  if (history.savedBaselinePath) lines.push(`- baseline saved: ${history.savedBaselinePath}`);
+  if (history.comparison) {
+    lines.push("");
+    lines.push(formatPerfBaselineComparison(history.comparison));
+  }
+  return lines.join("\n");
+}
+function readValue(argv, index, flag) {
+  const value = argv[index];
+  if (!value || value.startsWith("--")) throw new Error(`Missing value for ${flag}`);
+  return value;
+}
+function parseProfile(value) {
+  if (value === "all" || value === "runtime" || value === "http" || value === "runtime-ab" || value === "runtime-soak" || value === "http-memory") return value;
+  throw new Error(`Invalid --profile value: ${value}`);
+}
+function parseRuntimeVariant(value) {
+  if (value === "default" || value === "fiber-only" || value === "active-hooks" || value === "recorder" || value === "wide-scheduler") return value;
+  throw new Error(`Invalid runtime variant: ${value}`);
+}
+function parseVariants(value) {
+  const allowed = new Set(HTTP_PROFILE_VARIANTS);
+  return Object.freeze(value.split(",").map((item) => item.trim()).filter(Boolean).map((item) => {
+    if (!allowed.has(item)) {
+      throw new Error(`Invalid HTTP profile variant: ${item}`);
+    }
+    return item;
+  }));
+}
+function parsePositive(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`${flag} must be a positive number`);
+  return Math.floor(parsed);
+}
+function parseNonNegative(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) throw new Error(`${flag} must be a non-negative number`);
+  return Math.floor(parsed);
+}
+function parseNonNegativeNumber(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) throw new Error(`${flag} must be a non-negative number`);
+  return parsed;
+}
+function envInt(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? Math.floor(parsed) : fallback;
+}
+function envNumber(name) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function envString(name) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  return raw.trim();
+}
+function envBool(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  return raw === "1" || raw.toLowerCase() === "true" || raw.toLowerCase() === "yes";
+}
+function envProfile(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  return parseProfile(raw.trim());
+}
+function envRuntimeVariant(name) {
+  const raw = process.env[name];
+  if (!raw || raw.trim() === "") return void 0;
+  return parseRuntimeVariant(raw.trim());
+}
+function envVariants(name) {
+  const raw = process.env[name];
+  if (!raw || raw.trim() === "") return void 0;
+  return parseVariants(raw);
+}
+main(process.argv.slice(2)).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

package/dist/perf/index.cjs

@@ -0,0 +1,141 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk7ZPEZ57Lcjs = require('../chunk-7ZPEZ57L.cjs');
+require('../chunk-PD4EJTQC.cjs');
+require('../chunk-KQLYONSE.cjs');
+require('../chunk-5EC274J5.cjs');
+require('../chunk-L6VB5N7Q.cjs');
+require('../chunk-KZJQ723N.cjs');
+require('../chunk-SA6HUJVI.cjs');
+require('../chunk-AGR5B2BC.cjs');
+require('../chunk-JF5WGYJJ.cjs');
+require('../chunk-F6XWZQY4.cjs');
+require('../chunk-WBGRHGBP.cjs');
+require('../chunk-52PPNNI4.cjs');
+require('../chunk-3LOYJFRR.cjs');
+require('../chunk-GLE2WY7Z.cjs');
+require('../chunk-MVGUEJ5Z.cjs');
+require('../chunk-CZIVE6NT.cjs');
+require('../chunk-OBGZSXTJ.cjs');
+
+// src/perf/budget.ts
+async function runRuntimePerfBudget(options = {}) {
+  const ab = await _chunk7ZPEZ57Lcjs.profileRuntimeAb.call(void 0, {
+    ...options,
+    thresholds: {
+      maxRegressionPercent: _nullishCoalesce(_optionalChain([options, 'access', _ => _.thresholds, 'optionalAccess', _2 => _2.maxRegressionPercent]), () => ( 50)),
+      minSignificantDeltaPercent: _nullishCoalesce(_optionalChain([options, 'access', _3 => _3.thresholds, 'optionalAccess', _4 => _4.minSignificantDeltaPercent]), () => ( 5))
+    }
+  });
+  const minOpsPerSecond = positiveNumber(options.minOpsPerSecond, 1e4);
+  const maxHeapDeltaMb = positiveNumber(options.maxHeapDeltaMb, 32);
+  const violations = [];
+  for (const violation of ab.budgetViolations) {
+    violations.push({ area: "regression", message: violation });
+  }
+  for (const result of ab.candidate.results) {
+    if (result.units >= 1e3 && result.operationsPerSecond < minOpsPerSecond) {
+      violations.push({
+        area: "throughput",
+        message: `${result.name} throughput ${result.operationsPerSecond} ops/s is below ${minOpsPerSecond} ops/s`
+      });
+    }
+  }
+  if (ab.memory.delta.heapUsedMb > maxHeapDeltaMb) {
+    violations.push({
+      area: "memory",
+      message: `runtime A/B heap delta ${ab.memory.delta.heapUsedMb}MB exceeds ${maxHeapDeltaMb}MB`
+    });
+  }
+  return Object.freeze({
+    ab,
+    passed: violations.length === 0,
+    violations: Object.freeze(violations.map((item) => Object.freeze(item)))
+  });
+}
+function formatRuntimePerfBudgetReport(report) {
+  const lines = [];
+  lines.push(`Runtime performance budget: ${report.passed ? "pass" : "fail"}`);
+  lines.push(`baseline=${report.ab.baselineVariant} candidate=${report.ab.candidateVariant}`);
+  for (const comparison of report.ab.comparisons) {
+    const sign = comparison.deltaPercent >= 0 ? "+" : "";
+    lines.push(`- ${comparison.primitive}: ${sign}${comparison.deltaPercent}%`);
+  }
+  if (report.violations.length > 0) {
+    lines.push("");
+    lines.push("Violations");
+    for (const violation of report.violations) {
+      lines.push(`- [${violation.area}] ${violation.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+function positiveNumber(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, value);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.HTTP_PROFILE_VARIANTS = _chunk7ZPEZ57Lcjs.HTTP_PROFILE_VARIANTS; exports.captureMemorySnapshot = _chunk7ZPEZ57Lcjs.captureMemorySnapshot; exports.comparePerfToBaseline = _chunk7ZPEZ57Lcjs.comparePerfToBaseline; exports.compareRuntimeProfiles = _chunk7ZPEZ57Lcjs.compareRuntimeProfiles; exports.createPerfHistoryEntry = _chunk7ZPEZ57Lcjs.createPerfHistoryEntry; exports.defaultPerfHistoryDirectory = _chunk7ZPEZ57Lcjs.defaultPerfHistoryDirectory; exports.diagnoseRuntimeProfile = _chunk7ZPEZ57Lcjs.diagnoseRuntimeProfile; exports.diffMemorySnapshots = _chunk7ZPEZ57Lcjs.diffMemorySnapshots; exports.extractPerfMetrics = _chunk7ZPEZ57Lcjs.extractPerfMetrics; exports.forceGc = _chunk7ZPEZ57Lcjs.forceGc; exports.formatHttpMemoryLabReport = _chunk7ZPEZ57Lcjs.formatHttpMemoryLabReport; exports.formatPerfBaselineComparison = _chunk7ZPEZ57Lcjs.formatPerfBaselineComparison; exports.formatPerformanceReport = _chunk7ZPEZ57Lcjs.formatPerformanceReport; exports.formatRuntimeAbReport = _chunk7ZPEZ57Lcjs.formatRuntimeAbReport; exports.formatRuntimePerfBudgetReport = formatRuntimePerfBudgetReport; exports.formatRuntimeSoakReport = _chunk7ZPEZ57Lcjs.formatRuntimeSoakReport; exports.hasGc = _chunk7ZPEZ57Lcjs.hasGc; exports.loadPerfBaseline = _chunk7ZPEZ57Lcjs.loadPerfBaseline; exports.makePerfRecorder = _chunk7ZPEZ57Lcjs.makePerfRecorder; exports.profileHttpLayers = _chunk7ZPEZ57Lcjs.profileHttpLayers; exports.profileHttpMemoryLab = _chunk7ZPEZ57Lcjs.profileHttpMemoryLab; exports.profileMemoryRetention = _chunk7ZPEZ57Lcjs.profileMemoryRetention; exports.profileRuntimeAb = _chunk7ZPEZ57Lcjs.profileRuntimeAb; exports.profileRuntimePrimitives = _chunk7ZPEZ57Lcjs.profileRuntimePrimitives; exports.profileRuntimeSoak = _chunk7ZPEZ57Lcjs.profileRuntimeSoak; exports.readPerfHistory = _chunk7ZPEZ57Lcjs.readPerfHistory; exports.recommendPerformance = _chunk7ZPEZ57Lcjs.recommendPerformance; exports.recordPerfHistoryRun = _chunk7ZPEZ57Lcjs.recordPerfHistoryRun; exports.runBrassPerformanceProfile = _chunk7ZPEZ57Lcjs.runBrassPerformanceProfile; exports.runRuntimePerfBudget = runRuntimePerfBudget; exports.savePerfBaseline = _chunk7ZPEZ57Lcjs.savePerfBaseline; exports.summarizePerfEvents = _chunk7ZPEZ57Lcjs.summarizePerfEvents; exports.writePerfHistoryEntry = _chunk7ZPEZ57Lcjs.writePerfHistoryEntry;