@agjs/tsforge 0.1.19 → 0.2.1

package/scripts/web-sweep.ts

@@ -0,0 +1,292 @@
+// A/B sweep over the REAL thing: full web-app builds from the benchmark catalog,
+// not toy logic seeds. Orchestrates headless-build.ts as a subprocess per
+// (feature-variant x repeat), toggling features via env (TSFORGE_TTSR etc.),
+// then aggregates pass-rate + turns into the same statistical report the logic
+// sweep uses (Wilson intervals + two-proportion z-test vs a baseline variant).
+//
+// Each build is a from-scratch multi-entity app (up to webMaxTurns turns, large
+// token spend), so this is GATED: it prints the plan and exits unless
+// TSFORGE_WEB_CONFIRM=1 is set — a real run can cost hours and significant API
+// credits on a cloud flagship.
+//
+// Run (dry-run plan):  TSFORGE_WEB_APP=saas-crm bun run packages/core/scripts/web-sweep.ts
+// Run (for real):      TSFORGE_WEB_APP=saas-crm TSFORGE_FEATURE_VARIANTS=ttsr \
+//                        TSFORGE_WEB_REPEATS=2 TSFORGE_WEB_CONFIRM=1 \
+//                        bun run packages/core/scripts/web-sweep.ts [react|vanilla]
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveActiveModel } from "../src/models-config";
+import { LOOP_LIMITS } from "../src/loop";
+import {
+  buildSweepReport,
+  renderSweepReportMarkdown,
+  type IRunRecord,
+} from "../src/eval";
+import { BENCHMARK_CATALOG, findBenchmarkApp } from "./benchmark-catalog";
+
+/** A feature variant: dimension name -> "1" (on) | "0" (off). */
+type IFeatureVariant = Record<string, string>;
+
+/** The env var each known feature dimension toggles (mirrors sweep.ts so a web
+ *  A/B reads the same flags the logic A/B does). */
+const DIMENSION_ENV: Record<string, string> = {
+  ttsr: "TSFORGE_TTSR",
+  hashline: "TSFORGE_HASHLINE",
+  lsp_write_feedback: "TSFORGE_LSP_WRITE_FEEDBACK",
+};
+
+/** Parse `TSFORGE_FEATURE_VARIANTS` ("ttsr,hashline") into the cartesian product
+ *  of on/off per dimension. Empty -> a single unnamed baseline variant. */
+function parseVariants(spec: string): IFeatureVariant[] {
+  const dims = spec
+    .split(",")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+
+  let combos: IFeatureVariant[] = [{}];
+
+  for (const dim of dims) {
+    const next: IFeatureVariant[] = [];
+
+    for (const combo of combos) {
+      next.push({ ...combo, [dim]: "1" }, { ...combo, [dim]: "0" });
+    }
+
+    combos = next;
+  }
+
+  return combos;
+}
+
+/** The env overrides that realize a variant (only known dimensions are mapped). */
+function variantEnv(variant: IFeatureVariant): Record<string, string> {
+  const env: Record<string, string> = {};
+
+  for (const [dim, state] of Object.entries(variant)) {
+    const key = DIMENSION_ENV[dim];
+
+    if (key !== undefined) {
+      env[key] = state === "1" ? "1" : "0";
+    }
+  }
+
+  return env;
+}
+
+/** A stable label like "ttsr=on,hashline=off"; "baseline" when no dimensions. */
+function variantLabel(variant: IFeatureVariant): string {
+  const parts = Object.entries(variant)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([dim, state]) => `${dim}=${state === "1" ? "on" : "off"}`);
+
+  return parts.length > 0 ? parts.join(",") : "baseline";
+}
+
+/** The baseline label to compare against: the all-off variant when there are
+ *  dimensions (so deltas read as "the feature ON vs OFF"), else "baseline". */
+function baselineLabel(variants: IFeatureVariant[]): string {
+  const allOff = variants.find((v) =>
+    Object.values(v).every((state) => state === "0")
+  );
+
+  return allOff === undefined ? "baseline" : variantLabel(allOff);
+}
+
+interface ISweepConfig {
+  readonly slug: string;
+  readonly framework: string;
+  readonly variants: IFeatureVariant[];
+  readonly repeats: number;
+}
+
+/** Sortable timestamp `YYYYMMDD-HHMMSS`. */
+function stamp(): string {
+  const d = new Date();
+  const p = (n: number): string => String(n).padStart(2, "0");
+
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+
+const EVALS_ROOT = join(import.meta.dir, "..", "..", "..", "evals");
+const HEADLESS = join(import.meta.dir, "headless-build.ts");
+
+/** Stream a child's stdout to our terminal while keeping a small tail buffer so
+ *  we can parse its final `[status · N turn(s)]` summary line. */
+async function teeStdout(stream: ReadableStream<Uint8Array>): Promise<string> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let tail = "";
+
+  for (;;) {
+    const chunk = await reader.read();
+
+    if (chunk.done) {
+      break;
+    }
+
+    const text = decoder.decode(chunk.value);
+
+    process.stdout.write(text);
+    tail = `${tail}${text}`.slice(-4096);
+  }
+
+  return tail;
+}
+
+interface IBuildOutcome {
+  readonly passed: boolean;
+  readonly turns: number;
+  readonly ms: number;
+}
+
+/** Run ONE headless web build in its own dir with the variant's feature env. */
+async function runOneBuild(
+  config: ISweepConfig,
+  variant: IFeatureVariant,
+  dir: string
+): Promise<IBuildOutcome> {
+  const started = performance.now();
+  const proc = Bun.spawn(
+    ["bun", HEADLESS, "--app", config.slug, config.framework, dir],
+    {
+      env: { ...process.env, ...variantEnv(variant) },
+      stdout: "pipe",
+      stderr: "inherit",
+    }
+  );
+  const tail = await teeStdout(proc.stdout);
+  const code = await proc.exited;
+  const ms = performance.now() - started;
+  const match = /\[\w+ · (\d+) turn/.exec(tail);
+
+  return {
+    passed: code === 0,
+    turns: match?.[1] === undefined ? 0 : Number(match[1]),
+    ms,
+  };
+}
+
+/** Print the run plan and the cost warning. Returns the total build count. */
+function printPlan(config: ISweepConfig, model: string): number {
+  const total = config.variants.length * config.repeats;
+
+  process.stdout.write(
+    `\nWEB A/B SWEEP — the real thing (full app builds)\n` +
+      `  app:       ${config.slug} (${config.framework})\n` +
+      `  model:     ${model}\n` +
+      `  variants:  ${config.variants.map(variantLabel).join(", ")}\n` +
+      `  repeats:   ${config.repeats}\n` +
+      `  builds:    ${total} total\n\n` +
+      `Each build is a from-scratch multi-entity app: up to ` +
+      `${LOOP_LIMITS.webMaxTurns} model turns, vite build + browser render gate, ` +
+      `large token spend. ${total} of them runs SEQUENTIALLY and can take hours ` +
+      `and significant API credits on a cloud flagship.\n`
+  );
+
+  return total;
+}
+
+/** Run the full sweep, returning one record per build for aggregation. */
+async function runSweep(
+  config: ISweepConfig,
+  runDir: string
+): Promise<IRunRecord[]> {
+  const records: IRunRecord[] = [];
+  let index = 0;
+  const total = config.variants.length * config.repeats;
+
+  for (const variant of config.variants) {
+    const label = variantLabel(variant);
+
+    for (let repeat = 1; repeat <= config.repeats; repeat += 1) {
+      index += 1;
+      const dir = join(runDir, `${label}-${String(repeat)}`);
+
+      mkdirSync(dir, { recursive: true });
+      process.stdout.write(
+        `\n=== build ${String(index)}/${String(total)}: ${config.slug} ${label} #${String(repeat)} ===\n`
+      );
+
+      const outcome = await runOneBuild(config, variant, dir);
+
+      records.push({
+        label,
+        passed: outcome.passed,
+        cycles: outcome.turns,
+        ms: outcome.ms,
+      });
+      process.stdout.write(
+        `  -> ${outcome.passed ? "PASS" : "FAIL"} (${String(outcome.turns)} turns, ${(outcome.ms / 1000).toFixed(0)}s)\n`
+      );
+    }
+  }
+
+  return records;
+}
+
+/** Resolve the sweep config from env/argv, or print the catalog and exit. */
+function resolveConfig(): ISweepConfig | undefined {
+  const slug = process.env.TSFORGE_WEB_APP ?? "";
+  const app = findBenchmarkApp(slug);
+
+  if (app === undefined) {
+    const list = BENCHMARK_CATALOG.map(
+      (a, i) => `  ${String(i + 1)}. ${a.slug} — ${a.name}`
+    ).join("\n");
+
+    process.stderr.write(
+      `set TSFORGE_WEB_APP to a benchmark slug. catalog:\n${list}\n`
+    );
+
+    return undefined;
+  }
+
+  const framework = process.argv[2] === "vanilla" ? "vanilla" : "react";
+  const variants = parseVariants(process.env.TSFORGE_FEATURE_VARIANTS ?? "");
+  const repeats = Math.max(1, Number(process.env.TSFORGE_WEB_REPEATS ?? "1"));
+
+  return { slug: app.slug, framework, variants, repeats };
+}
+
+async function main(): Promise<void> {
+  const config = resolveConfig();
+
+  if (config === undefined) {
+    process.exit(2);
+  }
+
+  const { entry } = await resolveActiveModel();
+
+  printPlan(config, entry.model);
+
+  if (process.env.TSFORGE_WEB_CONFIRM !== "1") {
+    process.stdout.write(
+      `\nDRY RUN — set TSFORGE_WEB_CONFIRM=1 to actually run these builds.\n`
+    );
+    process.exit(0);
+  }
+
+  const runDir = join(
+    EVALS_ROOT,
+    "runs",
+    `web-sweep-${config.slug}-${stamp()}`
+  );
+
+  mkdirSync(runDir, { recursive: true });
+
+  const records = await runSweep(config, runDir);
+  const report = buildSweepReport(records, baselineLabel(config.variants));
+  const markdown = renderSweepReportMarkdown(report);
+
+  process.stdout.write(`\n${markdown}\n`);
+
+  const reportPath = join(runDir, "report.json");
+
+  writeFileSync(
+    reportPath,
+    `${JSON.stringify({ config, records, report }, null, 2)}\n`
+  );
+  process.stdout.write(`\nsaved ${reportPath}\n`);
+}
+
+await main();

package/src/browser/index.ts

@@ -1,8 +1,11 @@
 export {
   renderCheck,
+  summarizeAxeViolations,
+  checkPerfBudget,
   type IRenderOptions,
   type IRenderExpect,
   type IRenderResult,
   type IStep,
+  type IPerfBudget,
 } from "./oracle";
 export { parseChecks } from "./checks";

package/src/browser/oracle.ts

@@ -1,4 +1,5 @@
 import { resolve, dirname, basename, join } from "node:path";
+import { isRecord } from "../lib/guards";
 // `playwright` is an OPTIONAL peer: bundling it (+ a browser binary) into every
 // install is too heavy, so the import is dynamic and the render-check skips when
 // it's absent. The type-only import is erased at runtime, so it can't crash a
@@ -14,6 +15,20 @@ async function loadChromium(): Promise<typeof Chromium | null> {
   }
 }
 
+/** Run axe against a page and return its raw result; null when @axe-core/
+ *  playwright isn't installed (a11y is an optional enhancement, like the browser
+ *  itself). Kept untyped at the boundary — extractAxeViolations narrows it. */
+async function runAxe(page: Page): Promise<unknown> {
+  try {
+    const mod = await import("@axe-core/playwright");
+    const builder = new mod.AxeBuilder({ page });
+
+    return await builder.analyze();
+  } catch {
+    return null;
+  }
+}
+
 /**
  * The browser oracle — renders a built web page in headless chromium and reports
  * whether it actually WORKS, beyond what tsc/eslint can see: it fails on uncaught
@@ -55,22 +70,121 @@ export interface IRenderOptions {
    *  single-page smoke misses them. Served with SPA fallback so the client
    *  router handles the path. Empty/undefined → no crawl (unchanged behavior). */
   routes?: string[];
+  /** Run axe accessibility checks on the page (and each crawled route). Serious
+   *  and critical violations become gate errors; minor/moderate are skipped.
+   *  Skipped gracefully when @axe-core/playwright isn't installed. */
+  a11y?: boolean;
+  /** Directory to write a screenshot per page/route into (desktop + mobile
+   *  viewports). An artifact for human/visual review — never a pass/fail signal. */
+  screenshotDir?: string;
+  /** A perf budget (DOM node count + mount time) checked on the initial page. */
+  perfBudget?: IPerfBudget;
   /** Navigation timeout (default 15s). */
   timeoutMs?: number;
 }
 
+/** Screenshot viewports — a desktop and a mobile pass per page. */
+const VIEWPORTS = [
+  { name: "desktop", width: 1280, height: 800 },
+  { name: "mobile", width: 390, height: 844 },
+] as const;
+
 export interface IRenderResult {
   ok: boolean;
   /** Human-readable failures (console errors, page errors, missing content). */
   errors: string[];
   /** True when the check was skipped because playwright isn't installed. */
   skipped?: boolean;
+  /** Paths of screenshots captured (when `screenshotDir` was set). */
+  screenshots?: string[];
+}
+
+/** A simple performance budget: fail the render when the built app blows past
+ *  these. Intentionally minimal (no full Lighthouse) — a tripwire, not a profiler. */
+export interface IPerfBudget {
+  /** Max total DOM nodes after load (a proxy for over-heavy render trees). */
+  maxDomNodes?: number;
+  /** Max time from navigation start to DOMContentLoaded, in ms. */
+  maxMountMs?: number;
+}
+
+/** axe impact levels that FAIL the a11y check — minor/moderate are reported by
+ *  axe but don't gate (too noisy to block a build on). */
+const AXE_FAIL_IMPACTS = new Set(["serious", "critical"]);
+
+/** The subset of an axe violation the oracle reports on. */
+interface IAxeViolation {
+  id: string;
+  impact: string | undefined;
+  nodeCount: number;
+}
+
+/** Extract the reportable violations from axe's (untyped, dynamically-imported)
+ *  result — narrowed with guards, no casts. */
+function extractAxeViolations(result: unknown): IAxeViolation[] {
+  if (!isRecord(result) || !Array.isArray(result.violations)) {
+    return [];
+  }
+
+  const out: IAxeViolation[] = [];
+
+  for (const v of result.violations) {
+    if (!isRecord(v) || typeof v.id !== "string") {
+      continue;
+    }
+
+    out.push({
+      id: v.id,
+      impact: typeof v.impact === "string" ? v.impact : undefined,
+      nodeCount: Array.isArray(v.nodes) ? v.nodes.length : 0,
+    });
+  }
+
+  return out;
+}
+
+/** Turn axe violations into gate errors — only serious/critical fail. Pure. */
+export function summarizeAxeViolations(
+  violations: readonly IAxeViolation[],
+  where: string
+): string[] {
+  return violations
+    .filter((v) => v.impact !== undefined && AXE_FAIL_IMPACTS.has(v.impact))
+    .map(
+      (v) =>
+        `a11y ${v.impact ?? "?"} at ${where}: ${v.id} (${String(v.nodeCount)} node(s))`
+    );
+}
+
+/** Evaluate a perf budget against measured values → gate errors. Pure. */
+export function checkPerfBudget(
+  domNodes: number,
+  mountMs: number,
+  budget: IPerfBudget,
+  where: string
+): string[] {
+  const errors: string[] = [];
+
+  if (budget.maxDomNodes !== undefined && domNodes > budget.maxDomNodes) {
+    errors.push(
+      `perf at ${where}: ${String(domNodes)} DOM nodes > budget ${String(budget.maxDomNodes)}`
+    );
+  }
+
+  if (budget.maxMountMs !== undefined && mountMs > budget.maxMountMs) {
+    errors.push(
+      `perf at ${where}: mount ${String(Math.round(mountMs))}ms > budget ${String(budget.maxMountMs)}ms`
+    );
+  }
+
+  return errors;
 }
 
 export async function renderCheck(
   opts: IRenderOptions
 ): Promise<IRenderResult> {
   const errors: string[] = [];
+  const screenshots: string[] = [];
   const chromium = await loadChromium();
 
   // No playwright → skip the render check rather than fail the gate. The build
@@ -87,7 +201,10 @@ export async function renderCheck(
   const browser = await chromium.launch({ args: ["--no-sandbox"] });
 
   try {
-    const page = await browser.newPage();
+    // Page via an explicit context (not browser.newPage()) — axe-core/playwright
+    // requires a context-owned page; browser.close() tears the context down too.
+    const context = await browser.newContext();
+    const page = await context.newPage();
     const timeout = opts.timeoutMs ?? 15_000;
 
     page.on("console", (message) => {
@@ -113,30 +230,39 @@ export async function renderCheck(
           waitUntil: "load",
           timeout,
         });
-        await runChecks(page, opts, errors);
+        await runChecks(page, opts, errors, screenshots);
 
         if (opts.routes !== undefined && opts.routes.length > 0) {
-          await crawlRoutes(page, base, opts.routes, errors, timeout);
+          await crawlRoutes(page, base, opts.routes, errors, timeout, {
+            opts,
+            screenshots,
+          });
         }
       } finally {
         await server.stop(true);
       }
     } else {
       await page.setContent(opts.html ?? "", { waitUntil: "load", timeout });
-      await runChecks(page, opts, errors);
+      await runChecks(page, opts, errors, screenshots);
     }
 
-    return { ok: errors.length === 0, errors };
+    return {
+      ok: errors.length === 0,
+      errors,
+      ...(screenshots.length > 0 ? { screenshots } : {}),
+    };
   } finally {
     await browser.close();
   }
 }
 
-/** The expectation + step + smoke checks that run against the loaded page. */
+/** The expectation + step + smoke checks that run against the loaded page, then
+ *  the optional quality oracles (a11y, perf budget, screenshots). */
 async function runChecks(
   page: Page,
   opts: IRenderOptions,
-  errors: string[]
+  errors: string[],
+  screenshots: string[]
 ): Promise<void> {
   await checkExpectations(page, opts.expect, errors);
 
@@ -147,6 +273,76 @@ async function runChecks(
   if (opts.smoke === true) {
     await runSmoke(page, errors);
   }
+
+  await runQualityOracles(page, opts, "index", errors, screenshots);
+}
+
+/** The opt-in quality layer: accessibility (axe), a perf budget, and screenshots.
+ *  Each is independent and skips cleanly when not requested / dep absent. */
+async function runQualityOracles(
+  page: Page,
+  opts: IRenderOptions,
+  where: string,
+  errors: string[],
+  screenshots: string[]
+): Promise<void> {
+  if (opts.a11y === true) {
+    const violations = extractAxeViolations(await runAxe(page));
+
+    errors.push(...summarizeAxeViolations(violations, where));
+  }
+
+  if (opts.perfBudget !== undefined) {
+    const { domNodes, mountMs } = await measurePage(page);
+
+    errors.push(...checkPerfBudget(domNodes, mountMs, opts.perfBudget, where));
+  }
+
+  if (opts.screenshotDir !== undefined) {
+    await capturePage(page, opts.screenshotDir, where, screenshots);
+  }
+}
+
+/** Measure DOM size + mount time for the perf budget. */
+async function measurePage(
+  page: Page
+): Promise<{ domNodes: number; mountMs: number }> {
+  return page.evaluate(() => {
+    const nav = performance.getEntriesByType("navigation")[0];
+    const mountMs =
+      nav instanceof PerformanceNavigationTiming
+        ? nav.domContentLoadedEventEnd - nav.startTime
+        : 0;
+
+    return { domNodes: document.querySelectorAll("*").length, mountMs };
+  });
+}
+
+/** Filesystem-safe label for a route (e.g. "/a/b" → "a-b", "/" → "index"). */
+function routeLabel(route: string): string {
+  const cleaned = route.replace(/^\/+|\/+$/g, "").replace(/\//g, "-");
+
+  return cleaned.length === 0 ? "index" : cleaned;
+}
+
+/** Capture a desktop + mobile screenshot of the current page into `dir`. */
+async function capturePage(
+  page: Page,
+  dir: string,
+  label: string,
+  screenshots: string[]
+): Promise<void> {
+  for (const vp of VIEWPORTS) {
+    const path = join(dir, `${label}-${vp.name}.png`);
+
+    try {
+      await page.setViewportSize({ width: vp.width, height: vp.height });
+      await page.screenshot({ path, fullPage: true });
+      screenshots.push(path);
+    } catch {
+      // A screenshot is a best-effort artifact, never a gate failure.
+    }
+  }
 }
 
 /** Serve a directory on an ephemeral localhost port. SPA FALLBACK: an
@@ -187,7 +383,8 @@ async function crawlRoutes(
   base: string,
   routes: readonly string[],
   errors: string[],
-  timeout: number
+  timeout: number,
+  quality: { opts: IRenderOptions; screenshots: string[] }
 ): Promise<void> {
   for (const route of routes) {
     try {
@@ -207,7 +404,17 @@ async function crawlRoutes(
 
       if (blank) {
         errors.push(`route ${route} rendered blank`);
+        continue;
       }
+
+      // a11y + screenshots per route (perf budget stays an initial-page check).
+      await runQualityOracles(
+        page,
+        { ...quality.opts, perfBudget: undefined },
+        routeLabel(route),
+        errors,
+        quality.screenshots
+      );
     } catch (error) {
       errors.push(
         `route ${route} failed to load: ${error instanceof Error ? error.message : String(error)}`

package/src/cli.ts

@@ -102,11 +102,15 @@ export interface ICliArgs {
   /** Plan mode: a from-scratch build pauses after the design phase to show its
    *  plan for review/edit before implementing (`--plan`; also toggled by /plan). */
   plan: boolean;
+  /** Keep the auto-gate at the strict TS floor only — do NOT append the
+   *  project's discovered tests (`--strict-floor-only`). By default the auto-gate
+   *  also runs the project's tests, so "green" means floor + tests pass. */
+  strictFloorOnly: boolean;
 }
 
 const BOOL_FLAGS: Record<
   string,
-  "continue" | "noGate" | "web" | "log" | "plan"
+  "continue" | "noGate" | "web" | "log" | "plan" | "strictFloorOnly"
 > = {
   "--continue": "continue",
   "-c": "continue",
@@ -114,6 +118,7 @@ const BOOL_FLAGS: Record<
   "--web": "web",
   "--log": "log",
   "--plan": "plan",
+  "--strict-floor-only": "strictFloorOnly",
 };
 
 const VALUE_FLAGS = new Set([
@@ -140,6 +145,7 @@ export function parseArgs(argv: readonly string[]): ICliArgs {
     web: false,
     log: false,
     plan: false,
+    strictFloorOnly: false,
   };
 
   for (let i = 0; i < argv.length; i += 1) {
@@ -795,18 +801,30 @@ async function baseGate(
   }
 
   const { detectStack } = await import("./stack-detection");
-  const { loadTsforgeConfig, resolveActivePacks, normalizeRuleOverrides } =
-    await import("./config/tsforge-config");
+  const {
+    loadTsforgeConfig,
+    resolveActivePacks,
+    normalizeRuleOverrides,
+    resolveProjectProfile,
+  } = await import("./config/tsforge-config");
 
   const stackProfile = await detectStack(args.dir);
   const config = await loadTsforgeConfig(args.dir);
   const activePacks = resolveActivePacks(stackProfile.packs, config);
   const ruleOverrides = normalizeRuleOverrides(config);
+  const profile = resolveProjectProfile(config);
 
   const auto = await buildGate(
     args.dir,
     activePacks,
-    Object.keys(ruleOverrides).length > 0 ? ruleOverrides : undefined
+    Object.keys(ruleOverrides).length > 0 ? ruleOverrides : undefined,
+    {
+      enableTypeAware: profile === "strict",
+      // "Green" should mean the strict floor AND the project's own tests pass —
+      // not just that it type-checks and lints. discoverTestCommand appends them
+      // only when the project actually has tests; --strict-floor-only opts out.
+      includeTests: !args.strictFloorOnly,
+    }
   );
 
   return { accept: auto.command, gateLabel: auto.label };

package/src/config/index.ts

@@ -4,5 +4,13 @@ export {
   loadTsforgeConfig,
   resolveActivePacks,
   normalizeRuleOverrides,
+  resolveProjectProfile,
   type ITsforgeProjectConfig,
 } from "./tsforge-config";
+export {
+  PROFILE_DEFINITIONS,
+  DEFAULT_PROFILE,
+  isProfileId,
+  resolveProfileMetaRuleOverrides,
+  type ProfileId,
+} from "./profiles";