@usefragments/core 1.10.2 → 2.0.0

package/src/analysis-plan/analysis-plan-v1.test.ts

@@ -0,0 +1,320 @@
+import { describe, expect, it } from "vitest";
+import {
+  CoverageValidationErrorV1,
+  analysisObligationsDigestV1,
+  analysisPlanDigestV1,
+  buildAnalysisPlanV1,
+  coverageArtifactDigestV1,
+  deriveCoverageSummaryV1,
+  parseAnalysisPlanV1,
+  type AnalysisPlanInputV1,
+  type CoverageRegionV1,
+} from "./index.js";
+
+const DIGEST_A = "a".repeat(64);
+const DIGEST_B = "b".repeat(64);
+
+function input(overrides: Partial<AnalysisPlanInputV1> = {}): AnalysisPlanInputV1 {
+  return {
+    binding: {
+      provider: "github",
+      providerInstanceId: "github.com",
+      repositoryExternalId: "R_1",
+      bindingId: "binding_1",
+    },
+    source: {
+      commitId: "commit-a",
+      treeId: "tree-a",
+      defaultBranch: "main",
+      acquiredBy: "github_app",
+    },
+    contract: { fcid: DIGEST_A, artifactDigest: DIGEST_B },
+    config: { path: "fragments.config.ts", digest: DIGEST_A },
+    profile: {
+      id: "react-web-v1",
+      version: "1.0.0",
+      capabilities: ["tsx", "css"],
+    },
+    regions: [
+      {
+        regionId: "styles",
+        pathPattern: "src/**/*.css",
+        kind: "style_source",
+        language: "css",
+        required: false,
+        requiredDialects: ["css"],
+        analyzer: { id: "css", interfaceVersion: "1", implementationVersion: "1.0.0" },
+      },
+      {
+        regionId: "components",
+        pathPattern: "src/**/*.tsx",
+        kind: "component_source",
+        language: "typescript",
+        required: true,
+        requiredDialects: ["tsx", "jsx"],
+        analyzer: { id: "react", interfaceVersion: "1", implementationVersion: "1.0.0" },
+      },
+    ],
+    limits: {
+      maxSourceFiles: 10_000,
+      maxSourceBytes: 20_000_000,
+      maxFileBytes: 1_000_000,
+      maxFacts: 100_000,
+      maxRegions: 1_000,
+      maxDiagnostics: 10_000,
+      maxDurationMs: 120_000,
+    },
+    evaluatorVersion: "evaluation-kernel:v2",
+    createdAt: "2026-09-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+describe("AnalysisPlanV1", () => {
+  it("has checked-in stable exact and obligations digests", () => {
+    const plan = buildAnalysisPlanV1(input());
+    expect(plan.digest).toBe("c9e854bd2e9f177708b41140a5515a32833ed96e7cab283a2ebfbb24fbca6b02");
+    expect(plan.obligationsDigest).toBe(
+      "97d866010baa7ea2711c40e7a4c501528696da1404ea65cd3ec88568bcb55221"
+    );
+    expect(plan.analysisPlanId).toBe(`apl_${plan.digest}`);
+    expect(parseAnalysisPlanV1(plan)).toEqual(plan);
+  });
+
+  it("normalizes only declared set-like arrays and region order", () => {
+    const first = buildAnalysisPlanV1(input());
+    const reordered = buildAnalysisPlanV1(
+      input({
+        profile: { ...input().profile, capabilities: ["css", "tsx", "css"] },
+        regions: [...input().regions].reverse().map((region) => ({
+          ...region,
+          requiredDialects: [...region.requiredDialects].reverse(),
+        })),
+      })
+    );
+    expect(reordered.digest).toBe(first.digest);
+    expect(reordered.obligationsDigest).toBe(first.obligationsDigest);
+  });
+
+  it("uses locale-independent Unicode ordering for plan and coverage digests", () => {
+    const regions = [
+      {
+        ...input().regions[0],
+        regionId: "ä-region",
+        pathPattern: "src/umlaut/**/*.css",
+        requiredDialects: ["ä-dialect", "z-dialect"],
+      },
+      {
+        ...input().regions[1],
+        regionId: "z-region",
+        pathPattern: "src/z/**/*.tsx",
+        requiredDialects: ["z-dialect", "ä-dialect"],
+      },
+    ];
+    const first = buildAnalysisPlanV1(
+      input({
+        profile: { ...input().profile, capabilities: ["ä-capability", "z-capability"] },
+        regions,
+      })
+    );
+    const reordered = buildAnalysisPlanV1(
+      input({
+        profile: { ...input().profile, capabilities: ["z-capability", "ä-capability"] },
+        regions: [...regions].reverse().map((region) => ({
+          ...region,
+          requiredDialects: [...region.requiredDialects].reverse(),
+        })),
+      })
+    );
+    expect(first.regions.map((region) => region.regionId)).toEqual(["z-region", "ä-region"]);
+    expect(first.profile.capabilities).toEqual(["z-capability", "ä-capability"]);
+    expect(first.digest).toBe("3a5248714219d09d52c629bf97195b27642545a8dd736eb54f5914d9d10536cd");
+    expect(first.obligationsDigest).toBe(
+      "18b8467e9bf0526bc2dec1558adb36513b34a9f7b2250b1ce806552b4f65eb01"
+    );
+    expect(reordered.digest).toBe(first.digest);
+
+    const observations: CoverageRegionV1[] = [
+      {
+        regionId: "ä-region",
+        state: "analyzed",
+        fileCount: 1,
+        byteCount: 10,
+        diagnosticIds: ["ä-diagnostic", "z-diagnostic"],
+      },
+      {
+        regionId: "z-region",
+        state: "analyzed",
+        fileCount: 1,
+        byteCount: 10,
+        diagnosticIds: ["z-diagnostic", "ä-diagnostic"],
+      },
+    ];
+    const coverageDigest = coverageArtifactDigestV1(first, observations);
+    expect(coverageDigest).toBe("db5169e2e6b6388b30ba3ca44674eb770cb0427d2b1bbb586e98454502343c86");
+    expect(coverageArtifactDigestV1(reordered, [...observations].reverse())).toBe(coverageDigest);
+  });
+
+  it("separates exact source identity from source-independent obligations", () => {
+    const first = buildAnalysisPlanV1(input());
+    const nextCommit = buildAnalysisPlanV1(
+      input({ source: { ...input().source, commitId: "commit-b", treeId: "tree-b" } })
+    );
+    expect(nextCommit.digest).not.toBe(first.digest);
+    expect(nextCommit.obligationsDigest).toBe(first.obligationsDigest);
+
+    const nextContract = buildAnalysisPlanV1(
+      input({ contract: { ...input().contract, fcid: "c".repeat(64) } })
+    );
+    expect(nextContract.obligationsDigest).not.toBe(first.obligationsDigest);
+  });
+
+  it("excludes display branch and timestamp from authority digests", () => {
+    const first = buildAnalysisPlanV1(input());
+    const displayOnly = buildAnalysisPlanV1(
+      input({
+        source: { ...input().source, defaultBranch: "renamed-default" },
+        createdAt: "2026-09-02T00:00:00.000Z",
+      })
+    );
+    expect(displayOnly.digest).toBe(first.digest);
+    expect(displayOnly.obligationsDigest).toBe(first.obligationsDigest);
+  });
+
+  it("rejects tampered derived identity", () => {
+    const plan = buildAnalysisPlanV1(input());
+    expect(() => parseAnalysisPlanV1({ ...plan, digest: DIGEST_B })).toThrow();
+  });
+
+  it("enforces plan-specific region and byte-limit relationships", () => {
+    expect(() =>
+      buildAnalysisPlanV1(input({ limits: { ...input().limits, maxRegions: 1 } }))
+    ).toThrow(/maxRegions/u);
+    expect(() =>
+      buildAnalysisPlanV1(
+        input({
+          limits: {
+            ...input().limits,
+            maxSourceBytes: 100,
+            maxFileBytes: 101,
+          },
+        })
+      )
+    ).toThrow(/maxFileBytes/u);
+  });
+
+  it("builds and verifies a plan at the 1,000-region public bound", () => {
+    const regions = Array.from({ length: 1_000 }, (_, index) => ({
+      ...input().regions[0],
+      regionId: `region-${index.toString().padStart(4, "0")}`,
+      pathPattern: `src/area-${index}/**/*.css`,
+    }));
+    const built = buildAnalysisPlanV1(input({ regions }));
+    expect(built.regions).toHaveLength(1_000);
+    expect(parseAnalysisPlanV1(built)).toEqual(built);
+  });
+});
+
+describe("CoverageRegionV1", () => {
+  const complete: CoverageRegionV1[] = [
+    { regionId: "components", state: "analyzed", fileCount: 4, byteCount: 400, diagnosticIds: [] },
+    {
+      regionId: "styles",
+      state: "unsupported",
+      fileCount: 2,
+      byteCount: 100,
+      diagnosticIds: ["d-1"],
+    },
+  ];
+
+  it("derives required and optional summaries without trusting a submitted summary", () => {
+    const plan = buildAnalysisPlanV1(input());
+    expect(deriveCoverageSummaryV1(plan, complete)).toEqual({
+      plannedRegions: 2,
+      observedRegions: 2,
+      requiredRegions: 1,
+      requiredByState: {
+        analyzed: 1,
+        unsupported: 0,
+        excluded_by_contract: 0,
+        skipped_limit: 0,
+        failed: 0,
+      },
+      optionalByState: {
+        analyzed: 0,
+        unsupported: 1,
+        excluded_by_contract: 0,
+        skipped_limit: 0,
+        failed: 0,
+      },
+      eligibleFiles: 6,
+      analyzedFiles: 4,
+      analyzedBytes: 400,
+    });
+    expect(coverageArtifactDigestV1(plan, complete)).toBe(
+      "d970c7a194fc25c6fc81dde1b90e00379220e924bb5ed2dbf37885c634ae7182"
+    );
+  });
+
+  it.each([
+    [[complete[0]], ["styles"], []],
+    [[complete[1]], [], ["components"]],
+  ] as const)(
+    "names missing optional and required observations",
+    (coverage, optional, required) => {
+      try {
+        deriveCoverageSummaryV1(buildAnalysisPlanV1(input()), [...coverage]);
+        throw new Error("expected coverage validation to fail");
+      } catch (error) {
+        expect(error).toBeInstanceOf(CoverageValidationErrorV1);
+        const coverageError = error as CoverageValidationErrorV1;
+        expect(coverageError.missingOptionalRegionIds).toEqual(optional);
+        expect(coverageError.missingRequiredRegionIds).toEqual(required);
+      }
+    }
+  );
+
+  it("rejects duplicate and unknown observations", () => {
+    expect(() =>
+      deriveCoverageSummaryV1(buildAnalysisPlanV1(input()), [...complete, complete[0]])
+    ).toThrow(CoverageValidationErrorV1);
+    expect(() =>
+      deriveCoverageSummaryV1(buildAnalysisPlanV1(input()), [
+        ...complete,
+        { ...complete[0], regionId: "unknown" },
+      ])
+    ).toThrow(CoverageValidationErrorV1);
+  });
+
+  it.each([
+    ["files", { maxSourceFiles: 5 }, complete],
+    ["bytes", { maxSourceBytes: 450, maxFileBytes: 450 }, complete],
+    [
+      "diagnostics",
+      { maxDiagnostics: 1 },
+      complete.map((row) =>
+        row.regionId === "styles" ? { ...row, diagnosticIds: ["d-1", "d-2"] } : row
+      ),
+    ],
+  ] as const)("rejects coverage beyond the plan's %s limit", (_kind, limits, observations) => {
+    const plan = buildAnalysisPlanV1(input({ limits: { ...input().limits, ...limits } }));
+    expect(() => deriveCoverageSummaryV1(plan, [...observations])).toThrow(
+      CoverageValidationErrorV1
+    );
+  });
+
+  it("represents zero-region coverage without implying support", () => {
+    const plan = buildAnalysisPlanV1(input({ regions: [] }));
+    expect(deriveCoverageSummaryV1(plan, [])).toMatchObject({
+      plannedRegions: 0,
+      observedRegions: 0,
+      requiredRegions: 0,
+    });
+  });
+
+  it("keeps public digest helpers equal to built records", () => {
+    const plan = buildAnalysisPlanV1(input());
+    expect(analysisPlanDigestV1(plan)).toBe(plan.digest);
+    expect(analysisObligationsDigestV1(plan)).toBe(plan.obligationsDigest);
+  });
+});

package/src/analysis-plan/coverage.ts

@@ -0,0 +1,181 @@
+import { canonicalPreimage, compareCanonicalStrings, sha256Hex } from "../contract/hash.js";
+import { digestHexSchema, type DigestHex } from "../domain-ids.js";
+import { parseAnalysisPlanV1 } from "./digest.js";
+import {
+  coverageRegionV1Schema,
+  coverageSummaryV1Schema,
+  type AnalysisPlanV1,
+  type CoverageRegionV1,
+  type CoverageStateV1,
+  type CoverageSummaryV1,
+} from "./types.js";
+
+const COVERAGE_STATES: readonly CoverageStateV1[] = [
+  "analyzed",
+  "unsupported",
+  "excluded_by_contract",
+  "skipped_limit",
+  "failed",
+];
+
+function emptyCounts(): Record<CoverageStateV1, number> {
+  return {
+    analyzed: 0,
+    unsupported: 0,
+    excluded_by_contract: 0,
+    skipped_limit: 0,
+    failed: 0,
+  };
+}
+
+export class CoverageValidationErrorV1 extends TypeError {
+  constructor(
+    message: string,
+    readonly duplicateRegionIds: readonly string[] = [],
+    readonly unknownRegionIds: readonly string[] = [],
+    readonly missingRequiredRegionIds: readonly string[] = [],
+    readonly missingOptionalRegionIds: readonly string[] = []
+  ) {
+    super(message);
+    this.name = "CoverageValidationErrorV1";
+  }
+}
+
+function normalizeCoverage(coverage: readonly CoverageRegionV1[]): CoverageRegionV1[] {
+  return coverage
+    .map((observation) =>
+      coverageRegionV1Schema.parse({
+        ...observation,
+        diagnosticIds: [...observation.diagnosticIds].sort(),
+      })
+    )
+    .sort((left, right) => compareCanonicalStrings(left.regionId, right.regionId));
+}
+
+function deriveCoverageSummaryFromNormalizedV1(
+  plan: AnalysisPlanV1,
+  coverage: CoverageRegionV1[]
+): CoverageSummaryV1 {
+  const planned = new Map(plan.regions.map((region) => [region.regionId, region]));
+  const seen = new Set<string>();
+  const duplicateRegionIds = new Set<string>();
+  const unknownRegionIds = new Set<string>();
+
+  for (const observation of coverage) {
+    if (seen.has(observation.regionId)) duplicateRegionIds.add(observation.regionId);
+    seen.add(observation.regionId);
+    if (!planned.has(observation.regionId)) unknownRegionIds.add(observation.regionId);
+  }
+
+  const missingRequiredRegionIds = plan.regions
+    .filter((region) => region.required && !seen.has(region.regionId))
+    .map((region) => region.regionId);
+  const missingOptionalRegionIds = plan.regions
+    .filter((region) => !region.required && !seen.has(region.regionId))
+    .map((region) => region.regionId);
+
+  if (
+    duplicateRegionIds.size > 0 ||
+    unknownRegionIds.size > 0 ||
+    missingRequiredRegionIds.length > 0 ||
+    missingOptionalRegionIds.length > 0
+  ) {
+    throw new CoverageValidationErrorV1(
+      "Coverage observations must join exactly once to every planned region",
+      [...duplicateRegionIds].sort(),
+      [...unknownRegionIds].sort(),
+      missingRequiredRegionIds.sort(),
+      missingOptionalRegionIds.sort()
+    );
+  }
+
+  const requiredByState = emptyCounts();
+  const optionalByState = emptyCounts();
+  let eligibleFiles = 0;
+  let analyzedFiles = 0;
+  let analyzedBytes = 0;
+  let observedBytes = 0;
+  let diagnosticCount = 0;
+
+  for (const observation of coverage) {
+    const region = planned.get(observation.regionId)!;
+    (region.required ? requiredByState : optionalByState)[observation.state] += 1;
+    if (observation.state !== "excluded_by_contract") eligibleFiles += observation.fileCount;
+    if (observation.state === "analyzed") {
+      analyzedFiles += observation.fileCount;
+      analyzedBytes += observation.byteCount;
+    }
+    observedBytes += observation.byteCount;
+    diagnosticCount += observation.diagnosticIds.length;
+  }
+
+  if (
+    !Number.isSafeInteger(eligibleFiles) ||
+    !Number.isSafeInteger(analyzedFiles) ||
+    !Number.isSafeInteger(analyzedBytes) ||
+    !Number.isSafeInteger(observedBytes) ||
+    !Number.isSafeInteger(diagnosticCount)
+  ) {
+    throw new RangeError("Coverage totals exceeded the safe integer range");
+  }
+  if (eligibleFiles > plan.limits.maxSourceFiles) {
+    throw new CoverageValidationErrorV1("Coverage file total exceeds the analysis-plan limit");
+  }
+  if (observedBytes > plan.limits.maxSourceBytes) {
+    throw new CoverageValidationErrorV1("Coverage byte total exceeds the analysis-plan limit");
+  }
+  if (diagnosticCount > plan.limits.maxDiagnostics) {
+    throw new CoverageValidationErrorV1(
+      "Coverage diagnostic total exceeds the analysis-plan limit"
+    );
+  }
+
+  for (const state of COVERAGE_STATES) {
+    if (
+      !Number.isSafeInteger(requiredByState[state]) ||
+      !Number.isSafeInteger(optionalByState[state])
+    ) {
+      throw new RangeError("Coverage count exceeded the safe integer range");
+    }
+  }
+
+  return coverageSummaryV1Schema.parse({
+    plannedRegions: plan.regions.length,
+    observedRegions: coverage.length,
+    requiredRegions: plan.regions.filter((region) => region.required).length,
+    requiredByState,
+    optionalByState,
+    eligibleFiles,
+    analyzedFiles,
+    analyzedBytes,
+  });
+}
+
+export function deriveCoverageSummaryV1(
+  rawPlan: AnalysisPlanV1,
+  rawCoverage: readonly CoverageRegionV1[]
+): CoverageSummaryV1 {
+  return deriveCoverageSummaryFromNormalizedV1(
+    parseAnalysisPlanV1(rawPlan),
+    normalizeCoverage(rawCoverage)
+  );
+}
+
+export function coverageArtifactDigestV1(
+  rawPlan: AnalysisPlanV1,
+  rawCoverage: readonly CoverageRegionV1[]
+): DigestHex {
+  const plan = parseAnalysisPlanV1(rawPlan);
+  const coverage = normalizeCoverage(rawCoverage);
+  const summary = deriveCoverageSummaryFromNormalizedV1(plan, coverage);
+  return digestHexSchema.parse(
+    sha256Hex(
+      canonicalPreimage({
+        schema: "analysis-coverage.v1",
+        analysisPlanDigest: plan.digest,
+        coverage,
+        summary,
+      })
+    )
+  );
+}

package/src/analysis-plan/digest.ts

@@ -0,0 +1,141 @@
+import { canonicalPreimage, compareCanonicalStrings, sha256Hex } from "../contract/hash.js";
+import { analysisPlanIdFromDigest, digestHexSchema, type DigestHex } from "../domain-ids.js";
+import {
+  normalizeRepositoryBindingKeyV1,
+  repositoryBindingDigestV1,
+} from "../repository-binding.js";
+import {
+  analysisPlanInputV1Schema,
+  analysisPlanV1Schema,
+  type AnalysisPlanInputV1,
+  type AnalysisPlanV1,
+  type AnalysisRegionV1,
+} from "./types.js";
+
+const sortedUnique = (values: readonly string[]): string[] => [...new Set(values)].sort();
+
+function semanticInput(input: AnalysisPlanInputV1 | AnalysisPlanV1): AnalysisPlanInputV1 {
+  return {
+    binding: input.binding,
+    source: input.source,
+    contract: input.contract,
+    config: input.config,
+    profile: input.profile,
+    regions: input.regions,
+    limits: input.limits,
+    evaluatorVersion: input.evaluatorVersion,
+    createdAt: input.createdAt,
+  };
+}
+
+function normalizeRegion(region: AnalysisRegionV1): AnalysisRegionV1 {
+  return {
+    ...region,
+    requiredDialects: sortedUnique(region.requiredDialects),
+    analyzer: { ...region.analyzer },
+  };
+}
+
+export function normalizeAnalysisPlanInputV1(
+  input: AnalysisPlanInputV1 | AnalysisPlanV1
+): AnalysisPlanInputV1 {
+  const semantic = semanticInput(input);
+  const normalized = {
+    ...semantic,
+    binding: normalizeRepositoryBindingKeyV1(semantic.binding),
+    source: { ...semantic.source },
+    contract: { ...semantic.contract },
+    config: { ...semantic.config },
+    profile: {
+      ...semantic.profile,
+      capabilities: sortedUnique(semantic.profile.capabilities),
+    },
+    regions: semantic.regions
+      .map(normalizeRegion)
+      .sort((left, right) => compareCanonicalStrings(left.regionId, right.regionId)),
+    limits: { ...semantic.limits },
+  };
+  return analysisPlanInputV1Schema.parse(normalized);
+}
+
+function obligationsProjection(normalized: AnalysisPlanInputV1): Record<string, unknown> {
+  return {
+    schema: "analysis-obligations.v1",
+    bindingDigest: repositoryBindingDigestV1(normalized.binding),
+    contract: normalized.contract,
+    config: normalized.config,
+    profile: normalized.profile,
+    regions: normalized.regions,
+    limits: normalized.limits,
+    evaluatorVersion: normalized.evaluatorVersion,
+  };
+}
+
+function exactPlanProjection(normalized: AnalysisPlanInputV1): Record<string, unknown> {
+  return {
+    schema: "analysis-plan.v1",
+    bindingDigest: repositoryBindingDigestV1(normalized.binding),
+    source: {
+      commitId: normalized.source.commitId,
+      treeId: normalized.source.treeId,
+      acquiredBy: normalized.source.acquiredBy,
+    },
+    contract: normalized.contract,
+    config: normalized.config,
+    profile: normalized.profile,
+    regions: normalized.regions,
+    limits: normalized.limits,
+    evaluatorVersion: normalized.evaluatorVersion,
+  };
+}
+
+export function analysisObligationsDigestV1(
+  input: AnalysisPlanInputV1 | AnalysisPlanV1
+): DigestHex {
+  const normalized = normalizeAnalysisPlanInputV1(input);
+  return digestHexSchema.parse(sha256Hex(canonicalPreimage(obligationsProjection(normalized))));
+}
+
+export function analysisPlanDigestV1(input: AnalysisPlanInputV1 | AnalysisPlanV1): DigestHex {
+  const normalized = normalizeAnalysisPlanInputV1(input);
+  return digestHexSchema.parse(sha256Hex(canonicalPreimage(exactPlanProjection(normalized))));
+}
+
+export function buildAnalysisPlanV1(input: AnalysisPlanInputV1): AnalysisPlanV1 {
+  const normalized = normalizeAnalysisPlanInputV1(input);
+  const digest = digestHexSchema.parse(
+    sha256Hex(canonicalPreimage(exactPlanProjection(normalized)))
+  );
+  return analysisPlanV1Schema.parse({
+    schemaVersion: 1,
+    analysisPlanId: analysisPlanIdFromDigest(digest),
+    ...normalized,
+    obligationsDigest: digestHexSchema.parse(
+      sha256Hex(canonicalPreimage(obligationsProjection(normalized)))
+    ),
+    digest,
+  }) as AnalysisPlanV1;
+}
+
+export function parseAnalysisPlanV1(value: unknown): AnalysisPlanV1 {
+  const parsed = analysisPlanV1Schema.parse(value);
+  const rebuilt = buildAnalysisPlanV1({
+    binding: parsed.binding,
+    source: parsed.source,
+    contract: parsed.contract,
+    config: parsed.config,
+    profile: parsed.profile,
+    regions: parsed.regions,
+    limits: parsed.limits,
+    evaluatorVersion: parsed.evaluatorVersion,
+    createdAt: parsed.createdAt,
+  });
+  if (
+    parsed.analysisPlanId !== rebuilt.analysisPlanId ||
+    parsed.digest !== rebuilt.digest ||
+    parsed.obligationsDigest !== rebuilt.obligationsDigest
+  ) {
+    throw new TypeError("AnalysisPlanV1 derived identity does not match its semantic projection");
+  }
+  return rebuilt;
+}

package/src/analysis-plan/index.ts

@@ -0,0 +1,34 @@
+export {
+  ANALYSIS_LIMIT_CEILINGS_V1,
+  ANALYSIS_PLAN_MAX_CAPABILITIES_V1,
+  ANALYSIS_PLAN_MAX_DIALECTS_PER_REGION_V1,
+  ANALYSIS_PLAN_MAX_REGIONS_V1,
+  analysisLimitsV1Schema,
+  analysisPlanInputV1Schema,
+  analysisPlanV1Schema,
+  analysisRegionV1Schema,
+  coverageRegionV1Schema,
+  coverageStateV1Schema,
+  coverageSummaryV1Schema,
+} from "./types.js";
+export type {
+  AnalysisLimitsV1,
+  AnalysisPlanInputV1,
+  AnalysisPlanV1,
+  AnalysisRegionV1,
+  CoverageRegionV1,
+  CoverageStateV1,
+  CoverageSummaryV1,
+} from "./types.js";
+export {
+  analysisObligationsDigestV1,
+  analysisPlanDigestV1,
+  buildAnalysisPlanV1,
+  normalizeAnalysisPlanInputV1,
+  parseAnalysisPlanV1,
+} from "./digest.js";
+export {
+  CoverageValidationErrorV1,
+  coverageArtifactDigestV1,
+  deriveCoverageSummaryV1,
+} from "./coverage.js";