frontend-project-context 1.0.0

package/src/project-context/contract-schema.mjs

@@ -0,0 +1,316 @@
+import { validateJsonValue } from "./canonical-json.mjs";
+import { fail } from "./errors.mjs";
+import { normalizeRelativePath } from "./path-policy.mjs";
+
+const ID = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/u;
+const ITEM_KINDS = new Set(["fact", "policy", "reference", "validation-description"]);
+const SOURCE_KINDS = new Set(["file", "path", "json-pointer", "human-decision", "external-reference"]);
+const SOURCE_STATUSES = new Set(["active", "deprecated"]);
+const STATUSES = new Set(["proposed", "approved", "deprecated"]);
+const SCOPE_KINDS = new Set(["project", "path-prefix", "file"]);
+const VERIFICATION_KINDS = new Set(["none", "file-exists", "json-value", "path-digest"]);
+const SHA256 = /^sha256:[a-f0-9]{64}$/u;
+
+function object(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    fail("schema-invalid", `${label} must be an object`);
+  }
+}
+
+function exactKeys(value, allowed, label) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) fail("schema-unknown-field", `${label} contains unknown field: ${key}`);
+  }
+}
+
+function string(value, label, options = {}) {
+  if (typeof value !== "string" || (!options.empty && value.length === 0)) {
+    fail("schema-invalid", `${label} must be a non-empty string`);
+  }
+}
+
+function stableId(value, label) {
+  string(value, label);
+  if (!ID.test(value)) fail("schema-invalid-id", `${label} must use stable lowercase dot/kebab naming`);
+}
+
+function uniqueStrings(values, label, options = {}) {
+  if (!Array.isArray(values) || (!options.empty && values.length === 0)) {
+    fail("schema-invalid", `${label} must be ${options.empty ? "an" : "a non-empty"} array`);
+  }
+  const seen = new Set();
+  for (const value of values) {
+    string(value, `${label} entry`);
+    if (seen.has(value)) fail("schema-duplicate", `${label} contains duplicate value: ${value}`);
+    seen.add(value);
+  }
+}
+
+function validateScope(scope, label) {
+  object(scope, label);
+  exactKeys(scope, new Set(["kind", "path"]), label);
+  if (!SCOPE_KINDS.has(scope.kind)) fail("schema-invalid-enum", `${label}.kind is invalid`);
+  if (scope.kind === "project") {
+    if (scope.path !== undefined && scope.path !== ".") {
+      fail("schema-invalid", `${label}.path must be omitted or '.' for project scope`);
+    }
+  } else {
+    scope.path = normalizeRelativePath(scope.path, { label: `${label}.path` });
+  }
+}
+
+export function sourceStatus(source) {
+  return source.status ?? "active";
+}
+
+export function sourceForContract(source, schemaVersion) {
+  return schemaVersion === 2 ? { ...structuredClone(source), status: "active" } : structuredClone(source);
+}
+
+export function sourceRegistrationShape(source) {
+  const copy = structuredClone(source);
+  delete copy.status;
+  delete copy.deprecation;
+  return copy;
+}
+
+export function validateSource(source, label = "source", options = {}) {
+  const contractSchemaVersion = options.contractSchemaVersion ?? 1;
+  object(source, label);
+  const allowed = new Set(["id", "kind", "path", "pointer", "reference", "digest"]);
+  if (contractSchemaVersion === 2) {
+    allowed.add("status");
+    allowed.add("deprecation");
+  }
+  exactKeys(source, allowed, label);
+  stableId(source.id, `${label}.id`);
+  if (!SOURCE_KINDS.has(source.kind)) fail("schema-invalid-enum", `${label}.kind is invalid`);
+  if (source.kind === "file" || source.kind === "path" || source.kind === "json-pointer") {
+    source.path = normalizeRelativePath(source.path, { label: `${label}.path` });
+    string(source.digest, `${label}.digest`);
+    if (!SHA256.test(source.digest)) fail("schema-invalid", `${label}.digest must be sha256`);
+    if (source.kind === "json-pointer") {
+      string(source.pointer, `${label}.pointer`, { empty: true });
+      if (source.pointer !== "" && !source.pointer.startsWith("/")) {
+        fail("schema-invalid", `${label}.pointer must use RFC 6901 syntax`);
+      }
+    } else if (source.pointer !== undefined) {
+      fail("schema-invalid", `${label}.pointer is only valid for json-pointer sources`);
+    }
+    if (source.reference !== undefined) fail("schema-invalid", `${label}.reference is not valid for local sources`);
+  } else {
+    string(source.reference, `${label}.reference`);
+    if (source.path !== undefined || source.pointer !== undefined) {
+      fail("schema-invalid", `${label} cannot contain a local path`);
+    }
+    if (source.digest !== null && source.digest !== undefined) {
+      fail("schema-invalid", `${label}.digest must be null or omitted for unverifiable sources`);
+    }
+  }
+  if (contractSchemaVersion === 2) {
+    if (!SOURCE_STATUSES.has(source.status)) fail("schema-invalid-enum", `${label}.status is invalid`);
+    if (source.status === "active" && source.deprecation !== undefined) {
+      fail("schema-invalid", `${label}.deprecation is not allowed for active sources`);
+    }
+    if (source.status === "deprecated") {
+      if (source.deprecation === undefined) fail("schema-invalid", `${label}.deprecation is required for deprecated sources`);
+      validateApproval(source.deprecation, `${label}.deprecation`);
+      if (source.deprecation.rationale === undefined || source.deprecation.rationale.length === 0) {
+        fail("schema-invalid", `${label}.deprecation.rationale must be a non-empty string`);
+      }
+    }
+  }
+  return source;
+}
+
+function validateApproval(approval, label) {
+  object(approval, label);
+  exactKeys(approval, new Set(["by", "at", "rationale"]), label);
+  string(approval.by, `${label}.by`);
+  string(approval.at, `${label}.at`);
+  if (!Number.isFinite(Date.parse(approval.at))) fail("schema-invalid", `${label}.at must be an ISO timestamp`);
+  if (approval.rationale !== undefined) string(approval.rationale, `${label}.rationale`, { empty: true });
+}
+
+function validateVerification(verification, label) {
+  object(verification, label);
+  exactKeys(verification, new Set(["kind", "source", "expected"]), label);
+  if (!VERIFICATION_KINDS.has(verification.kind)) fail("schema-invalid-enum", `${label}.kind is invalid`);
+  const hasSource = Object.hasOwn(verification, "source");
+  const hasExpected = Object.hasOwn(verification, "expected");
+  if (verification.kind === "none") {
+    if (hasSource || hasExpected) fail("schema-invalid", `${label} none verification cannot contain source or expected`);
+    return;
+  }
+  string(verification.source, `${label}.source`);
+  if (verification.kind === "file-exists" && hasExpected) {
+    fail("schema-invalid", `${label} file-exists verification cannot contain expected`);
+  }
+  if (verification.kind === "json-value" && !hasExpected) {
+    fail("schema-invalid", `${label} json-value verification requires expected`);
+  }
+  if (verification.kind === "json-value") {
+    try {
+      validateJsonValue(verification.expected);
+    } catch (error) {
+      fail("schema-invalid", `${label}.expected must be JSON-compatible`, { cause: error });
+    }
+  }
+  if (verification.kind === "path-digest" && hasExpected) {
+    string(verification.expected, `${label}.expected`);
+    if (!SHA256.test(verification.expected)) fail("schema-invalid", `${label}.expected must be sha256`);
+  }
+}
+
+export function validateItem(item, label = "item", options = {}) {
+  object(item, label);
+  exactKeys(
+    item,
+    new Set(["id", "kind", "subject", "value", "statement", "scope", "status", "sources", "overrides", "approval", "verification"]),
+    label,
+  );
+  stableId(item.id, `${label}.id`);
+  if (!ITEM_KINDS.has(item.kind)) fail("schema-invalid-enum", `${label}.kind is invalid`);
+  stableId(item.subject, `${label}.subject`);
+  if (!("value" in item)) fail("schema-invalid", `${label}.value is required`);
+  try {
+    validateJsonValue(item.value);
+  } catch (error) {
+    fail("schema-invalid", `${label}.value must be JSON-compatible`, { cause: error });
+  }
+  string(item.statement, `${label}.statement`);
+  validateScope(item.scope, `${label}.scope`);
+  if (!STATUSES.has(item.status)) fail("schema-invalid-enum", `${label}.status is invalid`);
+  uniqueStrings(item.sources, `${label}.sources`);
+  uniqueStrings(item.overrides, `${label}.overrides`, { empty: true });
+  for (const source of item.sources) stableId(source, `${label}.sources entry`);
+  for (const target of item.overrides) stableId(target, `${label}.overrides entry`);
+  if (item.status === "proposed" && item.approval !== undefined) {
+    fail("schema-invalid", `${label}.approval is not allowed for proposed items`);
+  }
+  if (item.status === "approved" && item.approval === undefined) {
+    fail("schema-invalid", `${label}.approval is required for approved items`);
+  }
+  if (item.approval !== undefined && item.status !== "proposed") validateApproval(item.approval, `${label}.approval`);
+  if (item.verification != null) validateVerification(item.verification, `${label}.verification`);
+  if (options.proposal && item.status !== "proposed") {
+    fail("proposal-not-proposed", `${label} must remain proposed`);
+  }
+  return item;
+}
+
+function assertUnique(records, label) {
+  const seen = new Set();
+  for (const record of records) {
+    if (seen.has(record.id)) fail("schema-duplicate-id", `${label} contains duplicate id: ${record.id}`);
+    seen.add(record.id);
+  }
+}
+
+export function validateContract(contract) {
+  object(contract, "contract");
+  exactKeys(contract, new Set(["schemaVersion", "project", "sources", "items"]), "contract");
+  if (![1, 2].includes(contract.schemaVersion)) fail("schema-version-unsupported", "contract.schemaVersion must be 1 or 2");
+  object(contract.project, "contract.project");
+  exactKeys(contract.project, new Set(["id", "name", "root"]), "contract.project");
+  stableId(contract.project.id, "contract.project.id");
+  string(contract.project.name, "contract.project.name");
+  if (contract.project.root !== ".") fail("schema-invalid", "contract.project.root must be '.'");
+  if (!Array.isArray(contract.sources) || !Array.isArray(contract.items)) {
+    fail("schema-invalid", "contract.sources and contract.items must be arrays");
+  }
+  contract.sources.forEach((source, index) => validateSource(source, `contract.sources[${index}]`, {
+    contractSchemaVersion: contract.schemaVersion,
+  }));
+  contract.items.forEach((item, index) => validateItem(item, `contract.items[${index}]`));
+  assertUnique(contract.sources, "contract.sources");
+  assertUnique(contract.items, "contract.items");
+  const sourcesById = new Map(contract.sources.map((source) => [source.id, source]));
+  for (const item of contract.items) {
+    for (const source of item.sources) {
+      const referenced = sourcesById.get(source);
+      if (!referenced) fail("source-reference-missing", `item ${item.id} references unknown source ${source}`);
+      if (item.status !== "deprecated" && sourceStatus(referenced) === "deprecated") {
+        fail("source-reference-deprecated", `item ${item.id} references deprecated source ${source}`);
+      }
+    }
+    if (item.verification?.kind !== "none" && item.verification?.source) {
+      const referenced = sourcesById.get(item.verification.source);
+      if (!referenced) {
+        fail("source-reference-missing", `item ${item.id} verification references unknown source ${item.verification.source}`);
+      }
+      if (item.status !== "deprecated" && sourceStatus(referenced) === "deprecated") {
+        fail("source-reference-deprecated", `item ${item.id} verification references deprecated source ${item.verification.source}`);
+      }
+    }
+  }
+  return contract;
+}
+
+export function validateProposal(proposal) {
+  object(proposal, "proposal");
+  exactKeys(proposal, new Set(["schemaVersion", "projectId", "sources", "items"]), "proposal");
+  if (proposal.schemaVersion !== 1) fail("schema-version-unsupported", "proposal.schemaVersion must be 1");
+  stableId(proposal.projectId, "proposal.projectId");
+  if (!Array.isArray(proposal.sources) || !Array.isArray(proposal.items)) {
+    fail("schema-invalid", "proposal.sources and proposal.items must be arrays");
+  }
+  proposal.sources.forEach((source, index) => validateSource(source, `proposal.sources[${index}]`));
+  proposal.items.forEach((item, index) => validateItem(item, `proposal.items[${index}]`, { proposal: true }));
+  assertUnique(proposal.sources, "proposal.sources");
+  assertUnique(proposal.items, "proposal.items");
+  const sourceIds = new Set(proposal.sources.map((source) => source.id));
+  for (const item of proposal.items) {
+    for (const source of item.sources) {
+      if (!sourceIds.has(source)) fail("source-reference-missing", `proposal item ${item.id} references unknown source ${source}`);
+    }
+  }
+  return proposal;
+}
+
+export function validateSourceLock(lock) {
+  object(lock, "sources lock");
+  exactKeys(lock, new Set(["schemaVersion", "sources"]), "sources lock");
+  if (lock.schemaVersion !== 1 || !Array.isArray(lock.sources)) fail("schema-invalid", "sources lock is invalid");
+  const seen = new Set();
+  for (const [index, entry] of lock.sources.entries()) {
+    object(entry, `sources lock entry ${index}`);
+    exactKeys(entry, new Set(["id", "digest"]), `sources lock entry ${index}`);
+    stableId(entry.id, `sources lock entry ${index}.id`);
+    string(entry.digest, `sources lock entry ${index}.digest`);
+    if (!SHA256.test(entry.digest)) fail("schema-invalid", "source lock digest must be sha256");
+    if (seen.has(entry.id)) fail("schema-duplicate-id", `sources lock contains duplicate id: ${entry.id}`);
+    seen.add(entry.id);
+  }
+  return lock;
+}
+
+export function validateProjectionLock(lock) {
+  object(lock, "projections lock");
+  exactKeys(lock, new Set(["schemaVersion", "projections"]), "projections lock");
+  if (lock.schemaVersion !== 1 || !Array.isArray(lock.projections)) fail("schema-invalid", "projections lock is invalid");
+  const seen = new Set();
+  for (const [index, entry] of lock.projections.entries()) {
+    object(entry, `projection entry ${index}`);
+    exactKeys(
+      entry,
+      new Set(["path", "target", "paths", "contractDigest", "bundleDigest", "contentDigest", "itemIds", "rendererVersion"]),
+      `projection entry ${index}`,
+    );
+    entry.path = normalizeRelativePath(entry.path, { label: `projection entry ${index}.path` });
+    if (entry.target !== "agents" && entry.target !== "ruler") fail("schema-invalid-enum", "projection target is invalid");
+    uniqueStrings(entry.paths, `projection entry ${index}.paths`);
+    entry.paths = entry.paths.map((value) => normalizeRelativePath(value, { allowRoot: true, label: "projection scope path" }));
+    for (const key of ["contractDigest", "bundleDigest", "contentDigest"]) {
+      string(entry[key], `projection entry ${index}.${key}`);
+      if (!SHA256.test(entry[key])) fail("schema-invalid", `projection ${key} must be sha256`);
+    }
+    uniqueStrings(entry.itemIds, `projection entry ${index}.itemIds`, { empty: true });
+    if (![1, 2, 3].includes(entry.rendererVersion)) {
+      fail("schema-version-unsupported", "projection rendererVersion must be 1, 2, or 3");
+    }
+    if (seen.has(entry.path)) fail("schema-duplicate", `projections lock contains duplicate path: ${entry.path}`);
+    seen.add(entry.path);
+  }
+  return lock;
+}

package/src/project-context/dashboard-model.mjs

@@ -0,0 +1,278 @@
+import path from "node:path";
+import { blockingContextFindings, checkExitCode, checkProject, findingSeverity } from "./checker.mjs";
+import { digestJson } from "./canonical-json.mjs";
+import { sourceStatus } from "./contract-schema.mjs";
+import { reviewSource, sourceImpact } from "./maintenance.mjs";
+import { describeScope, effectiveItems, scopeApplies } from "./scope-compiler.mjs";
+
+export const DASHBOARD_SCHEMA_VERSION = 3;
+
+const LOCAL_SOURCE_KINDS = new Set(["file", "path", "json-pointer"]);
+const ITEM_STATUS_ORDER = new Map([
+  ["proposed", 0],
+  ["approved", 1],
+  ["deprecated", 2],
+]);
+const ITEM_KINDS = ["fact", "policy", "reference", "validation-description"];
+
+function increment(record, key) {
+  record[key] = (record[key] ?? 0) + 1;
+}
+
+function stableStrings(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+
+function sourceLocator(source) {
+  if (source.kind === "json-pointer") return `${source.path}#${source.pointer}`;
+  return source.path ?? source.reference;
+}
+
+function findingTarget(finding) {
+  return finding.path ?? finding.source ?? finding.item ?? finding.subject ?? "project";
+}
+
+function decorateFinding(finding) {
+  return {
+    ...structuredClone(finding),
+    severity: findingSeverity(finding),
+    target: findingTarget(finding),
+  };
+}
+
+function healthStatus(findings) {
+  if (findings.some((finding) => findingSeverity(finding) === "conflict")) return "conflict";
+  if (blockingContextFindings(findings).length > 0) return "blocked";
+  return findings.length > 0 ? "attention" : "clean";
+}
+
+function sourceRelations(contract, sourceId, impact) {
+  const referencingItemIds = contract.items
+    .filter((item) => item.sources.includes(sourceId) || item.verification?.source === sourceId)
+    .map((item) => item.id);
+  return {
+    referenceCount: stableStrings(referencingItemIds).length,
+    directItemIds: impact.items
+      .filter((item) => item.reasons.includes("source"))
+      .map((item) => item.id),
+    verificationItemIds: impact.items
+      .filter((item) => item.reasons.includes("verification"))
+      .map((item) => item.id),
+    overrideDependentItemIds: impact.items
+      .filter((item) => item.reasons.includes("override-dependent"))
+      .map((item) => item.id),
+    fallbackItemIds: impact.fallbackItems.map((item) => item.id),
+    directProjectionPaths: [...impact.directProjectionPaths],
+    staleProjectionPaths: [...impact.staleProjectionPaths],
+  };
+}
+
+async function buildSourceModel(root, project, source) {
+  let impact;
+  let status;
+  let lockedDigest = null;
+  let currentDigest = null;
+  let reason;
+  if (sourceStatus(source) === "deprecated") {
+    status = "deprecated";
+    impact = sourceImpact(project, source.id);
+  } else if (LOCAL_SOURCE_KINDS.has(source.kind)) {
+    const review = await reviewSource(root, project, source.id);
+    ({ status, lockedDigest, currentDigest, reason } = review);
+    impact = review.impact;
+  } else {
+    status = source.kind === "human-decision" ? "manual" : "external";
+    impact = sourceImpact(project, source.id);
+  }
+  return {
+    id: source.id,
+    kind: source.kind,
+    locator: sourceLocator(source),
+    status,
+    contractDigest: source.digest ?? null,
+    lockedDigest,
+    currentDigest,
+    ...(reason ? { reason } : {}),
+    ...(source.deprecation ? { deprecation: structuredClone(source.deprecation) } : {}),
+    ...sourceRelations(project.contract, source.id, impact),
+  };
+}
+
+function addPathWithAncestors(paths, value) {
+  let current = value;
+  while (current && current !== ".") {
+    paths.add(current);
+    const parent = path.posix.dirname(current);
+    current = parent === current ? "." : parent;
+  }
+  paths.add(".");
+}
+
+function topLevelDirectory(value) {
+  if (!value || value === ".") return ".";
+  const first = value.split("/")[0];
+  return value.includes("/") ? first : ".";
+}
+
+function knownScopePaths(contract, projections) {
+  const paths = new Set(["."]);
+  for (const item of contract.items) {
+    if (item.scope.kind !== "project") addPathWithAncestors(paths, item.scope.path);
+  }
+  for (const source of contract.sources) {
+    if (source.path) addPathWithAncestors(paths, topLevelDirectory(source.path));
+  }
+  for (const projection of projections) addPathWithAncestors(paths, topLevelDirectory(projection.path));
+  return [...paths].sort((left, right) => left.localeCompare(right));
+}
+
+function emptyGroups() {
+  return Object.fromEntries(ITEM_KINDS.map((kind) => [kind, []]));
+}
+
+function buildScopeViews(contract, projections) {
+  const views = knownScopePaths(contract, projections).map((targetPath) => {
+    const applicableIds = contract.items
+      .filter((item) => item.status === "approved" && scopeApplies(item.scope, targetPath))
+      .map((item) => item.id);
+    try {
+      const effective = effectiveItems(contract.items, targetPath);
+      const itemIds = effective.map((item) => item.id);
+      const effectiveSet = new Set(itemIds);
+      const groups = emptyGroups();
+      for (const item of effective) groups[item.kind].push(item.id);
+      return {
+        path: targetPath,
+        itemIds,
+        groups,
+        excludedItems: applicableIds
+          .filter((id) => !effectiveSet.has(id))
+          .map((id) => ({ id, reason: "overridden" })),
+      };
+    } catch (error) {
+      return {
+        path: targetPath,
+        itemIds: [],
+        groups: emptyGroups(),
+        excludedItems: [],
+        error: {
+          code: error.code ?? "scope-unavailable",
+          message: error.message,
+        },
+      };
+    }
+  });
+  return views.map((view) => {
+    if (view.path === ".") return { ...view, siblingDifferences: [] };
+    const siblings = views.filter((candidate) =>
+      candidate.path !== "." &&
+      candidate.path !== view.path &&
+      path.posix.dirname(candidate.path) === path.posix.dirname(view.path),
+    );
+    const here = new Set(view.itemIds);
+    return {
+      ...view,
+      siblingDifferences: siblings.map((sibling) => {
+        const there = new Set(sibling.itemIds);
+        return {
+          path: sibling.path,
+          onlyHereItemIds: view.itemIds.filter((id) => !there.has(id)),
+          onlyThereItemIds: sibling.itemIds.filter((id) => !here.has(id)),
+        };
+      }).filter((difference) => difference.onlyHereItemIds.length > 0 || difference.onlyThereItemIds.length > 0),
+    };
+  });
+}
+
+function itemSort(left, right) {
+  return (
+    ITEM_STATUS_ORDER.get(left.status) - ITEM_STATUS_ORDER.get(right.status) ||
+    left.kind.localeCompare(right.kind) ||
+    left.id.localeCompare(right.id)
+  );
+}
+
+function buildItems(contract) {
+  return contract.items.map((item) => ({
+    ...structuredClone(item),
+    itemDigest: digestJson(item),
+    scopeLabel: describeScope(item.scope),
+  })).sort(itemSort);
+}
+
+function projectionStatus(codes) {
+  if (codes.includes("projection-ownership-conflict")) return "conflict";
+  if (codes.includes("projection-missing")) return "missing";
+  if (codes.includes("projection-unreadable") || codes.includes("projection-path-invalid")) return "unreadable";
+  if (codes.includes("projection-diverged")) return "diverged";
+  if (codes.some((code) => code === "projection-stale" || code === "projection-renderer-stale" || code === "projection-item-missing")) {
+    return "stale";
+  }
+  return codes.length > 0 ? "attention" : "healthy";
+}
+
+function buildProjections(project, findings) {
+  return project.projectionsLock.projections.map((entry) => {
+    const findingCodes = findings
+      .filter((finding) => finding.path === entry.path && finding.code.startsWith("projection-"))
+      .map((finding) => finding.code);
+    return {
+      ...structuredClone(entry),
+      status: projectionStatus(findingCodes),
+      findingCodes: stableStrings(findingCodes),
+    };
+  }).sort((left, right) => left.path.localeCompare(right.path));
+}
+
+function buildSummary(sources, items, projections) {
+  const sourceSummary = { registered: sources.length, referenced: sources.filter((source) => source.referenceCount > 0).length };
+  for (const source of sources) increment(sourceSummary, source.status);
+  sourceSummary.healthy = sourceSummary.unchanged ?? 0;
+
+  const itemSummary = { total: items.length, approved: 0, proposed: 0, deprecated: 0, byKind: {} };
+  for (const item of items) {
+    increment(itemSummary, item.status);
+    increment(itemSummary.byKind, item.kind);
+  }
+
+  const projectionSummary = { configured: projections.length, healthy: 0, stale: 0, missing: 0, unreadable: 0, diverged: 0, conflict: 0, attention: 0 };
+  for (const projection of projections) increment(projectionSummary, projection.status);
+  return { sources: sourceSummary, items: itemSummary, projections: projectionSummary };
+}
+
+export async function buildDashboardModel(root, project) {
+  const rawFindings = await checkProject(root, project);
+  const findings = rawFindings.map(decorateFinding);
+  const sources = (await Promise.all(
+    [...project.contract.sources]
+      .sort((left, right) => left.id.localeCompare(right.id))
+      .map((source) => buildSourceModel(root, project, source)),
+  ));
+  const projections = buildProjections(project, rawFindings);
+  const scopeViews = buildScopeViews(project.contract, projections);
+  const items = buildItems(project.contract);
+  const findingsByCode = {};
+  for (const finding of rawFindings) increment(findingsByCode, finding.code);
+
+  return {
+    schemaVersion: DASHBOARD_SCHEMA_VERSION,
+    project: structuredClone(project.contract.project),
+    digests: {
+      contract: project.contractDigest,
+      sourcesLock: project.sourcesLockDigest,
+      projectionsLock: project.projectionsLockDigest,
+    },
+    health: {
+      status: healthStatus(rawFindings),
+      exitCode: checkExitCode(rawFindings),
+      findingCount: rawFindings.length,
+      findingsByCode,
+    },
+    summary: buildSummary(sources, items, projections),
+    items,
+    sources,
+    scopeViews,
+    projections,
+    findings,
+  };
+}