@pbiplint/core 0.1.0

package/src/engine/run.ts

@@ -0,0 +1,67 @@
+import type { Indexes } from "../index/build.js";
+import type { Model } from "../model/types.js";
+import type { Finding, Rule } from "../rules/types.js";
+import type { ResolvedConfig } from "./config.js";
+import { isIgnored } from "./ignore.js";
+
+export interface SkippedRule {
+  id: string;
+  reason: "disabled" | "needsLiveModel";
+}
+
+export interface RuleError {
+  id: string;
+  message: string;
+}
+
+export interface RunResult {
+  findings: Finding[];
+  rulesRun: string[];
+  rulesSkipped: SkippedRule[];
+  ruleErrors: RuleError[];
+  ignored: number;
+}
+
+export function runRules(
+  model: Model,
+  indexes: Indexes,
+  rules: Rule[],
+  config: ResolvedConfig,
+): RunResult {
+  const result: RunResult = {
+    findings: [],
+    rulesRun: [],
+    rulesSkipped: [],
+    ruleErrors: [],
+    ignored: 0,
+  };
+  for (const rule of rules) {
+    if (config.disabled.has(rule.id)) {
+      result.rulesSkipped.push({ id: rule.id, reason: "disabled" });
+      continue;
+    }
+    if (rule.status === "needsLiveModel") {
+      result.rulesSkipped.push({ id: rule.id, reason: "needsLiveModel" });
+      continue;
+    }
+    result.rulesRun.push(rule.id);
+    let raw;
+    try {
+      raw = rule.check(model, { indexes });
+    } catch (e) {
+      result.ruleErrors.push({ id: rule.id, message: e instanceof Error ? e.message : String(e) });
+      continue;
+    }
+    for (const f of raw) {
+      if (isIgnored(f.object, rule.id)) {
+        result.ignored++;
+        continue;
+      }
+      const out: Finding = { ruleId: rule.id, objectType: f.objectType, objectName: f.objectName };
+      if (f.location) out.location = f.location;
+      if (f.detail !== undefined) out.detail = f.detail;
+      result.findings.push(out);
+    }
+  }
+  return result;
+}

package/src/format/index.ts

@@ -0,0 +1,37 @@
+import type { LintResult } from "../engine/lint.js";
+import { formatJson } from "./json.js";
+import { formatMarkdown } from "./markdown.js";
+import { formatSarif } from "./sarif.js";
+import {
+  formatText,
+  skippedLine,
+  summaryLine,
+  topGroups,
+  type FormatOptions,
+  type RuleHelp,
+} from "./text.js";
+
+export const FORMATS = ["text", "json", "markdown", "sarif"] as const;
+export type FormatName = (typeof FORMATS)[number];
+
+export function formatResult(
+  name: FormatName,
+  result: LintResult,
+  options: FormatOptions = {},
+): string {
+  switch (name) {
+    case "text":
+      return formatText(result, options);
+    case "json":
+      return formatJson(result, options);
+    case "markdown":
+      return formatMarkdown(result, options);
+    case "sarif":
+      return formatSarif(result, options);
+    default:
+      throw new Error(`Unknown format: ${String(name)}`);
+  }
+}
+
+export { formatJson, formatMarkdown, formatSarif, formatText, skippedLine, summaryLine, topGroups };
+export type { FormatOptions, RuleHelp };

package/src/format/json.ts

@@ -0,0 +1,22 @@
+import type { LintResult } from "../engine/lint.js";
+import { VERSION } from "../version.js";
+import type { FormatOptions } from "./text.js";
+
+export function formatJson(result: LintResult, options: FormatOptions = {}): string {
+  const doc = {
+    version: 1,
+    tool: { name: "pbiplint", version: options.toolVersion ?? VERSION },
+    summary: result.summary,
+    groups: result.groups.map((g) => ({
+      rule: g.rule,
+      count: g.findings.length,
+      findings: g.findings.map((f) => ({
+        objectType: f.objectType,
+        objectName: f.objectName,
+        ...(f.location ? { file: f.location.file, line: f.location.line } : {}),
+        ...(f.detail !== undefined ? { detail: f.detail } : {}),
+      })),
+    })),
+  };
+  return JSON.stringify(doc, null, 2) + "\n";
+}

package/src/format/markdown.ts

@@ -0,0 +1,37 @@
+import type { LintResult } from "../engine/lint.js";
+import { SEVERITY_LABEL } from "../rules/types.js";
+import { locationOf, skippedLine, summaryLine, topGroups, type FormatOptions } from "./text.js";
+
+const cell = (s: string): string => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+
+export function formatMarkdown(result: LintResult, _options: FormatOptions = {}): string {
+  const out: string[] = [
+    "# pbiplint report",
+    "",
+    `${summaryLine(result)}. ${skippedLine(result)}.`,
+    "",
+  ];
+  if (result.groups.length === 0) {
+    out.push("No findings.", "");
+    return out.join("\n");
+  }
+  out.push("## Fix these first", "");
+  topGroups(result).forEach((g, i) =>
+    out.push(`${i + 1}. **${g.rule.name}** (${g.findings.length}) [${g.rule.id}](${g.rule.url})`),
+  );
+  out.push("");
+  for (const g of result.groups) {
+    out.push(
+      `## ${SEVERITY_LABEL[g.rule.severity].toUpperCase()}: ${g.rule.name} (${g.findings.length})`,
+      "",
+    );
+    out.push(`[${g.rule.id}](${g.rule.url}) · ${g.rule.category}`, "");
+    out.push("| Object | Type | Location | Detail |", "|---|---|---|---|");
+    for (const f of g.findings)
+      out.push(
+        `| \`${cell(f.objectName)}\` | ${f.objectType} | ${locationOf(f)} | ${cell(f.detail ?? "")} |`,
+      );
+    out.push("");
+  }
+  return out.join("\n");
+}

package/src/format/sarif.ts

@@ -0,0 +1,85 @@
+import type { LintResult } from "../engine/lint.js";
+import { defaultRules } from "../rules/index.js";
+import type { Severity } from "../rules/types.js";
+import { VERSION } from "../version.js";
+import type { FormatOptions, RuleHelp } from "./text.js";
+
+const LEVEL: Record<Severity, "error" | "warning" | "note"> = {
+  3: "error",
+  2: "warning",
+  1: "note",
+};
+
+/** Rule summaries are Markdown with inline code; SARIF's plain-text slot gets them without the backticks. */
+const plain = (markdown: string): string => markdown.replace(/`/g, "");
+
+export function formatSarif(result: LintResult, options: FormatOptions = {}): string {
+  const byId = new Map((options.rules ?? defaultRules).map((r) => [r.id, r]));
+  // Code scanning resolves artifact URIs against the repository root, so the caller can prefix the
+  // model root's path. Finding locations themselves stay relative to the model root.
+  const prefix = options.pathPrefix ?? "";
+  // SARIF artifact URIs are URIs, so each path segment is percent-encoded: a model folder with a
+  // space in its name would otherwise produce a location code scanning cannot resolve.
+  const encodePath = (p: string): string => p.split("/").map(encodeURIComponent).join("/");
+  const uri = (file: string): string => encodePath(prefix ? `${prefix}/${file}` : file);
+  // GitHub renders help.markdown beside the alert and ignores helpUri, so the page link rides
+  // inside the help block as well.
+  const helpFor = (id: string, description: string, url: string): RuleHelp =>
+    options.help?.[id] ?? {
+      text: `${plain(description)}\n\nRead more: ${url}`,
+      markdown: `${description}\n\nRead more: ${url}`,
+    };
+  const rules = result.groups.map((g) => {
+    const full = byId.get(g.rule.id);
+    return {
+      id: g.rule.id,
+      name: g.rule.name,
+      shortDescription: { text: g.rule.name },
+      fullDescription: full
+        ? { text: plain(full.description), markdown: full.description }
+        : { text: g.rule.name },
+      help: helpFor(g.rule.id, full?.description ?? g.rule.name, g.rule.url),
+      helpUri: g.rule.url,
+      defaultConfiguration: { level: LEVEL[g.rule.severity] },
+      properties: { category: g.rule.category },
+    };
+  });
+  const results = result.groups.flatMap((g, ruleIndex) =>
+    g.findings.map((f) => ({
+      ruleId: g.rule.id,
+      ruleIndex,
+      level: LEVEL[g.rule.severity],
+      message: { text: `${f.objectName}: ${g.rule.name}${f.detail ? ` (${f.detail})` : ""}` },
+      ...(f.location
+        ? {
+            locations: [
+              {
+                physicalLocation: {
+                  artifactLocation: { uri: uri(f.location.file) },
+                  region: { startLine: f.location.line },
+                },
+              },
+            ],
+          }
+        : {}),
+    })),
+  );
+  const doc = {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "pbiplint",
+            version: options.toolVersion ?? VERSION,
+            informationUri: "https://pbiplint.com",
+            rules,
+          },
+        },
+        results,
+      },
+    ],
+  };
+  return JSON.stringify(doc, null, 2) + "\n";
+}

package/src/format/text.ts

@@ -0,0 +1,90 @@
+import type { LintResult } from "../engine/lint.js";
+import type { RankedGroup } from "../engine/rank.js";
+import { SEVERITY_LABEL, type Finding } from "../rules/types.js";
+
+/** Guidance for one rule in the two forms SARIF carries: plain text and Markdown. */
+export interface RuleHelp {
+  text: string;
+  markdown: string;
+}
+
+export interface FormatOptions {
+  toolVersion?: string;
+  /**
+   * Help per rule id for the SARIF help block, which code scanning shows beside each alert.
+   * The CLI passes the rule pages' Why, How to fix, and Quirks sections. Without it the block
+   * falls back to the rule's description and page URL.
+   */
+  help?: Readonly<Record<string, RuleHelp>>;
+  rules?: import("../rules/types.js").Rule[];
+  /**
+   * Posix path (forward slashes, no leading "./", no trailing slash) joined in front of each
+   * SARIF artifact URI so code scanning can resolve it from the repository root. The text, JSON,
+   * and markdown formats ignore it: their paths stay relative to the model root.
+   */
+  pathPrefix?: string;
+}
+
+const SEVERITY_TAG = { 3: "ERROR", 2: "WARN ", 1: "INFO " } as const;
+
+export const locationOf = (f: Finding): string =>
+  f.location ? `${f.location.file}:${f.location.line}` : "";
+
+/** "1 rule", "2 rules". Nouns that do not take an s ("info") are written out by the caller. */
+const plural = (n: number, noun: string): string => `${n} ${noun}${n === 1 ? "" : "s"}`;
+
+/** Summary sentence shared by the text and markdown formats. */
+export function summaryLine(result: LintResult): string {
+  const s = result.summary;
+  return `${plural(s.findings, "finding")} (${plural(s.errors, "error")}, ${plural(s.warnings, "warning")}, ${s.infos} info) in ${plural(s.files, "file")}`;
+}
+
+export function skippedLine(result: LintResult): string {
+  const s = result.summary;
+  const live = s.rulesSkipped.filter((r) => r.reason === "needsLiveModel").length;
+  const disabled = s.rulesSkipped.filter((r) => r.reason === "disabled").length;
+  const parts = [`${plural(s.rulesRun, "rule")} run`];
+  if (live) parts.push(`${plural(live, "rule")} skipped (need a live model)`);
+  if (disabled) parts.push(`${plural(disabled, "rule")} disabled by config`);
+  if (s.ignored) parts.push(`${plural(s.ignored, "finding")} ignored by annotation`);
+  return parts.join(", ");
+}
+
+export const topGroups = (result: LintResult, n = 5): RankedGroup[] => result.groups.slice(0, n);
+
+export function formatText(result: LintResult, _options: FormatOptions = {}): string {
+  const out: string[] = [`pbiplint: ${summaryLine(result)}`, skippedLine(result), ""];
+  if (result.groups.length === 0) {
+    out.push("No findings.", "");
+  } else {
+    out.push("Fix these first:");
+    topGroups(result).forEach((g, i) =>
+      out.push(
+        `  ${i + 1}. ${g.rule.name}  (${plural(g.findings.length, SEVERITY_LABEL[g.rule.severity])})`,
+      ),
+    );
+    out.push("");
+    for (const g of result.groups) {
+      out.push(
+        `${SEVERITY_TAG[g.rule.severity]}  ${g.rule.name}  ${g.rule.id}  (${g.findings.length})`,
+      );
+      out.push(`       ${g.rule.url}`);
+      // The location column is always emitted, empty or not, so a finding without a location never
+      // shifts its detail into the location column. Widths align within the group only.
+      const width = Math.max(...g.findings.map((f) => f.objectName.length));
+      const locWidth = Math.max(...g.findings.map((f) => locationOf(f).length));
+      for (const f of g.findings) {
+        const cols = [f.objectName.padEnd(width), locationOf(f).padEnd(locWidth), f.detail ?? ""];
+        out.push(`       ${cols.join("  ")}`.trimEnd());
+      }
+      out.push("");
+    }
+  }
+  // Rule crashes are always reported, including on a run where nothing else fired.
+  if (result.summary.ruleErrors.length) {
+    out.push("Rule errors (please report these):");
+    for (const e of result.summary.ruleErrors) out.push(`  ${e.id}: ${e.message}`);
+    out.push("");
+  }
+  return out.join("\n");
+}

package/src/index/build.ts

@@ -0,0 +1,18 @@
+import type { Model } from "../model/types.js";
+import { buildReferenceIndex, type ReferenceIndex } from "./references.js";
+import { buildRelationshipIndex, type RelationshipIndex } from "./relationships.js";
+import { buildUsageIndex, type UsageIndex } from "./usage.js";
+
+export interface Indexes {
+  relationships: RelationshipIndex;
+  usage: UsageIndex;
+  references: ReferenceIndex;
+}
+
+export function buildIndexes(model: Model): Indexes {
+  return {
+    relationships: buildRelationshipIndex(model),
+    usage: buildUsageIndex(model),
+    references: buildReferenceIndex(model),
+  };
+}

package/src/index/references.ts

@@ -0,0 +1,170 @@
+import type {
+  CalculationItem,
+  Column,
+  Measure,
+  Model,
+  Table,
+  TablePermission,
+} from "../model/types.js";
+
+export type RefOwnerKind =
+  "measure" | "calculatedColumn" | "calculatedTable" | "tablePermission" | "calculationItem";
+
+export interface DaxRef {
+  kind: "column" | "measure" | "unresolved";
+  /** Canonical table name of the resolved object. */
+  table?: string;
+  /** Canonical name of the resolved object, or the raw name when unresolved. */
+  name: string;
+  qualified: boolean;
+}
+
+export interface RefOwner {
+  kind: RefOwnerKind;
+  object: Measure | Column | Table | TablePermission | CalculationItem;
+  ownerTable?: Table;
+  expression: string;
+  refs: DaxRef[];
+}
+
+export interface ReferenceIndex {
+  owners: RefOwner[];
+  refsOf(object: object): DaxRef[];
+  columnReferencedBy(c: Column): RefOwner[];
+  measureReferencedBy(m: Measure): RefOwner[];
+}
+
+interface RawRef {
+  table?: string;
+  name: string;
+  qualified: boolean;
+}
+
+// Qualified: 'Table Name'[Column] or TableName[Column]. Bare: [Name]. An unquoted table name may
+// contain Unicode letters and digits (Año, Größe), so the identifier branch matches \p{L} and
+// \p{N} rather than ASCII word characters.
+const QUALIFIED = /(?:'((?:[^']|'')+)'\s*|([\p{L}_][\p{L}\p{N}_]*))\[([^\]]+)\]/gu;
+const BARE = /\[([^\]]+)\]/g;
+
+/**
+ * Regex approximation of DAX dependencies: qualified refs first, then bare refs whose `[` was not
+ * part of a qualified match. Strings and comments are not skipped; that is the upgrade path if a
+ * fixture ever breaks parity because of it.
+ */
+export function extractRefs(expression: string): RawRef[] {
+  const out: RawRef[] = [];
+  const consumed = new Set<number>();
+  for (const m of expression.matchAll(QUALIFIED)) {
+    const table = m[1] !== undefined ? m[1].replace(/''/g, "'") : m[2]!;
+    out.push({ table, name: m[3]!, qualified: true });
+    consumed.add(m.index! + m[0].length - m[3]!.length - 2);
+  }
+  for (const m of expression.matchAll(BARE)) {
+    if (consumed.has(m.index!)) continue;
+    out.push({ name: m[1]!, qualified: false });
+  }
+  return out;
+}
+
+const lower = (s: string): string => s.toLowerCase();
+const key = (table: string, name: string): string => `${lower(table)} ${lower(name)}`;
+
+export function buildReferenceIndex(model: Model): ReferenceIndex {
+  const tables = new Map<string, Table>(model.tables.map((t) => [lower(t.name), t]));
+  const columns = new Map<string, Column>();
+  const measures = new Map<string, Measure>();
+  for (const t of model.tables) {
+    for (const c of t.columns) columns.set(key(t.name, c.name), c);
+    for (const m of t.measures) measures.set(lower(m.name), m);
+  }
+  const columnOf = (t: Table, name: string): Column | undefined => columns.get(key(t.name, name));
+
+  const resolve = (raw: RawRef, ownerTable: Table | undefined, ownerKind: RefOwnerKind): DaxRef => {
+    if (raw.qualified) {
+      const t = tables.get(lower(raw.table!));
+      if (!t) return { kind: "unresolved", table: raw.table, name: raw.name, qualified: true };
+      const col = columnOf(t, raw.name);
+      if (col) return { kind: "column", table: t.name, name: col.name, qualified: true };
+      const meas = t.measures.find((m) => lower(m.name) === lower(raw.name));
+      if (meas) return { kind: "measure", table: t.name, name: meas.name, qualified: true };
+      return { kind: "unresolved", table: raw.table, name: raw.name, qualified: true };
+    }
+    const meas = measures.get(lower(raw.name));
+    if (meas) return { kind: "measure", table: meas.table.name, name: meas.name, qualified: false };
+    if (ownerKind === "calculationItem")
+      return { kind: "unresolved", name: raw.name, qualified: false };
+    if (ownerTable) {
+      const col = columnOf(ownerTable, raw.name);
+      if (col) return { kind: "column", table: ownerTable.name, name: col.name, qualified: false };
+    }
+    for (const t of model.tables) {
+      const col = columnOf(t, raw.name);
+      if (col) return { kind: "column", table: t.name, name: col.name, qualified: false };
+    }
+    return { kind: "unresolved", name: raw.name, qualified: false };
+  };
+
+  const owners: RefOwner[] = [];
+  const byObject = new Map<object, RefOwner>();
+  const add = (
+    kind: RefOwnerKind,
+    object: RefOwner["object"],
+    ownerTable: Table | undefined,
+    ...expressions: (string | undefined)[]
+  ) => {
+    const expression = expressions.filter((e): e is string => e !== undefined).join("\n");
+    const owner: RefOwner = {
+      kind,
+      object,
+      ownerTable,
+      expression,
+      refs: extractRefs(expression).map((r) => resolve(r, ownerTable, kind)),
+    };
+    owners.push(owner);
+    byObject.set(object, owner);
+  };
+  for (const t of model.tables) {
+    for (const m of t.measures) add("measure", m, t, m.expression, m.formatStringDefinition);
+    for (const c of t.columns)
+      if (c.kind === "calculated") add("calculatedColumn", c, t, c.expression);
+    if (t.kind === "calculated")
+      add(
+        "calculatedTable",
+        t,
+        t,
+        ...t.partitions.filter((p) => p.sourceType === "calculated").map((p) => p.source),
+      );
+    for (const item of t.calculationGroup?.items ?? [])
+      add("calculationItem", item, t, item.expression, item.formatStringDefinition);
+  }
+  for (const role of model.roles) {
+    for (const tp of role.tablePermissions)
+      if (tp.filter !== undefined)
+        add("tablePermission", tp, tables.get(lower(tp.table)), tp.filter);
+  }
+
+  const columnRefs = new Map<string, RefOwner[]>();
+  const measureRefs = new Map<string, RefOwner[]>();
+  for (const o of owners) {
+    for (const r of o.refs) {
+      if (r.kind === "column") {
+        const k = key(r.table!, r.name);
+        const arr = columnRefs.get(k) ?? [];
+        if (!arr.includes(o)) arr.push(o);
+        columnRefs.set(k, arr);
+      } else if (r.kind === "measure") {
+        const k = lower(r.name);
+        const arr = measureRefs.get(k) ?? [];
+        if (!arr.includes(o)) arr.push(o);
+        measureRefs.set(k, arr);
+      }
+    }
+  }
+
+  return {
+    owners,
+    refsOf: (object) => byObject.get(object)?.refs ?? [],
+    columnReferencedBy: (c) => columnRefs.get(key(c.table.name, c.name)) ?? [],
+    measureReferencedBy: (m) => measureRefs.get(lower(m.name)) ?? [],
+  };
+}

package/src/index/relationships.ts

@@ -0,0 +1,33 @@
+import type { Model, Relationship } from "../model/types.js";
+
+export interface RelationshipIndex {
+  all: Relationship[];
+  /** Relationships in which the column is the from-side or the to-side. */
+  forColumn(table: string, column: string): Relationship[];
+  /** Relationships in which the table is on either side. */
+  forTable(table: string): Relationship[];
+}
+
+const key = (table: string, column: string): string => `${table} ${column}`;
+
+function push(map: Map<string, Relationship[]>, k: string, r: Relationship): void {
+  const arr = map.get(k);
+  if (!arr) map.set(k, [r]);
+  else if (!arr.includes(r)) arr.push(r);
+}
+
+export function buildRelationshipIndex(model: Model): RelationshipIndex {
+  const byColumn = new Map<string, Relationship[]>();
+  const byTable = new Map<string, Relationship[]>();
+  for (const r of model.relationships) {
+    push(byColumn, key(r.fromTable, r.fromColumn), r);
+    push(byColumn, key(r.toTable, r.toColumn), r);
+    push(byTable, r.fromTable, r);
+    push(byTable, r.toTable, r);
+  }
+  return {
+    all: model.relationships,
+    forColumn: (table, column) => byColumn.get(key(table, column)) ?? [],
+    forTable: (table) => byTable.get(table) ?? [],
+  };
+}

package/src/index/usage.ts

@@ -0,0 +1,33 @@
+import type { Column, Model } from "../model/types.js";
+
+export interface UsageIndex {
+  /** Another column in the same table sorts by this column. */
+  usedInSortBy(c: Column): boolean;
+  /** A hierarchy level in the same table uses this column. */
+  usedInHierarchies(c: Column): boolean;
+  /** A variation anywhere names this column as its default column. */
+  usedInVariations(c: Column): boolean;
+}
+
+const key = (table: string, column: string): string => `${table} ${column}`;
+
+export function buildUsageIndex(model: Model): UsageIndex {
+  const sortTargets = new Set<string>();
+  const levelColumns = new Set<string>();
+  const variationDefaults = new Set<string>();
+  for (const t of model.tables) {
+    for (const c of t.columns) {
+      if (c.sortByColumn !== undefined) sortTargets.add(key(t.name, c.sortByColumn));
+      for (const v of c.variations)
+        if (v.defaultColumn)
+          variationDefaults.add(key(v.defaultColumn.table, v.defaultColumn.column));
+    }
+    for (const h of t.hierarchies)
+      for (const l of h.levels) if (l.column !== undefined) levelColumns.add(key(t.name, l.column));
+  }
+  return {
+    usedInSortBy: (c) => sortTargets.has(key(c.table.name, c.name)),
+    usedInHierarchies: (c) => levelColumns.has(key(c.table.name, c.name)),
+    usedInVariations: (c) => variationDefaults.has(key(c.table.name, c.name)),
+  };
+}

package/src/index.ts

@@ -0,0 +1,80 @@
+export { VERSION } from "./version.js";
+export {
+  ConfigError,
+  resolveConfig,
+  SEVERITY_BY_NAME,
+  type PbiplintConfig,
+  type ResolvedConfig,
+  type SeverityName,
+} from "./engine/config.js";
+export { IGNORE_ANNOTATION, isIgnored } from "./engine/ignore.js";
+export {
+  lint,
+  type LintFile,
+  type LintOptions,
+  type LintResult,
+  type LintSummary,
+} from "./engine/lint.js";
+export {
+  effectiveSeverity,
+  rank,
+  summarizeRule,
+  type RankedGroup,
+  type RuleSummary,
+} from "./engine/rank.js";
+export { runRules, type RuleError, type RunResult, type SkippedRule } from "./engine/run.js";
+export {
+  FORMATS,
+  formatResult,
+  formatJson,
+  formatMarkdown,
+  formatSarif,
+  formatText,
+  skippedLine,
+  summaryLine,
+  topGroups,
+  type FormatName,
+  type FormatOptions,
+  type RuleHelp,
+} from "./format/index.js";
+export { buildIndexes, type Indexes } from "./index/build.js";
+export {
+  extractRefs,
+  type DaxRef,
+  type RefOwner,
+  type RefOwnerKind,
+  type ReferenceIndex,
+} from "./index/references.js";
+export type { RelationshipIndex } from "./index/relationships.js";
+export type { UsageIndex } from "./index/usage.js";
+export { buildModel, splitQualifiedName } from "./model/build.js";
+export {
+  columnRef,
+  measureRef,
+  relationshipName,
+  RULE_URL_BASE,
+  ruleUrl,
+  slug,
+  tableRef,
+} from "./model/names.js";
+export type * from "./model/types.js";
+export {
+  allCalculationItems,
+  allColumns,
+  allMeasures,
+  allPartitions,
+  allTablePermissions,
+  columnObjectType,
+  finding,
+  namedObjects,
+  tableObjectType,
+} from "./rules/helpers.js";
+export { defaultRules } from "./rules/index.js";
+export { BPA_RULES, type BpaRuleMeta } from "./rules/microsoft-bpa/bpa-rules.data.js";
+export { bpaRule, liveModelRule, mapScope } from "./rules/microsoft-bpa/define.js";
+export { microsoftBpaRules } from "./rules/microsoft-bpa/index.js";
+export { PARSE_ISSUE } from "./rules/parse-issue.js";
+export * from "./rules/types.js";
+export { parseTmdl } from "./tmdl/parse.js";
+export { unquoteName, unquoteValue } from "./tmdl/quote.js";
+export type { ParsedFile, ParseIssue, TmdlNode, TmdlNodeKind } from "./tmdl/types.js";