filegrc 0.16.11 → 0.16.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "filegrc",
-  "version": "0.16.11",
+  "version": "0.16.13",
   "description": "Zero-dependency Git-native GRC engine",
   "license": "MIT",
   "repository": {

package/src/applicability-scope.js

@@ -1,6 +1,10 @@
 import { CALCULATED_REVISION_FIELDS, CALCULATED_REVISION_MAP_FIELDS, calculateRevision, canonicalCalculatedRevision, revisionsMatch } from "./revisions.js";
-import { getDataCommitHistory } from "./git.js";
-import { historicalWorkspace } from "./historical-workspace.js";
+import { reviewCommitsChangingTypes, reviewHistoricalWorkspace, reviewHistoryCommits, reviewHistoryContext } from "./historical-workspace.js";
+
+const scopeSourceTypes = new Set([
+  "workspace", "program", "commitment", "control", "complementary-control",
+  "system", "framework", "component", "vendor", "policy", "requirement"
+]);
 
 const excludedResourceFields = new Set([
   "applicabilityReview",
@@ -23,6 +27,13 @@ const unorderedStringArrayFields = new Set([
   "tags"
 ]);
 
+const applicabilityDecisionFields = {
+  requirement: ["frameworkId", "reference", "description", "parentRequirementId"],
+  control: ["statement", "requirementIds", "code", "activity", "controlType", "operationMode", "operationPattern", "systemIds", "policyIds", "componentIds", "evidenceSourceComponentIds"],
+  commitment: ["commitmentKind", "statement", "systemIds", "sourceResourceIds", "requirementIds", "controlIds", "customerFacing", "reportingRouteRequirements"],
+  "complementary-control": ["responsibleParty", "statement", "systemIds", "vendorId", "requirementIds", "commitmentIds", "relatedControlIds", "sourceDocumentIds", "componentIds"]
+};
+
 export function applicabilityScopeRevision(record, program, resources, model, options = {}) {
   const scopedResource = ["commitment", "control", "complementary-control"].includes(record?.type)
     && !options.legacyBroadScope && !options.legacyBroadCommitment;
@@ -79,8 +90,7 @@ export function applicabilityScopeRevision(record, program, resources, model, op
           .sort((left, right) => left.requirementId.localeCompare(right.requirementId))
       })
     },
-    resource: canonicalObject(model, record.type, Object.fromEntries(Object.entries(record)
-      .filter(([field]) => !excludedResourceFields.has(field)))),
+    resource: applicabilityResourceFacts(record, model, options),
     systems: resources
       .filter(({ type, id }) => type === "system" && selectedSystemIds.has(id))
       .sort(compareRecordIds)
@@ -192,6 +202,17 @@ function compareRecordIds(left, right) {
   return left.id.localeCompare(right.id);
 }
 
+function applicabilityResourceFacts(record, model, options) {
+  const fields = Number(model.modelVersion) >= 11 && !options.legacyResourceProjection
+    ? applicabilityDecisionFields[record.type] : null;
+  if (!fields) return canonicalObject(model, record.type, Object.fromEntries(Object.entries(record)
+    .filter(([field]) => !excludedResourceFields.has(field))));
+  const value = Object.fromEntries(["id", "type", "title", "externalIds", "extensions", ...fields]
+    .filter((field) => record[field] !== undefined).map((field) => [field, record[field]]));
+  value.unavailable = ["not-applicable", "retired", "superseded"].includes(record.status);
+  return canonicalObject(model, record.type, value);
+}
+
 export function applicabilityReviewIsCurrent(review, record, program, resources, model, root = null) {
   if (
     review?.scopeRevision
@@ -200,12 +221,17 @@ export function applicabilityReviewIsCurrent(review, record, program, resources,
     && Number(model?.modelVersion || 0) < 7
   ) return true;
   if (!review?.scopeRevision) return false;
+  if (Number(model.modelVersion) >= 11 && record?.type === "control"
+    && (review.decision === "not-applicable") !== (record.status === "not-applicable")) return false;
+  if (Number(model.modelVersion) >= 11 && ["retired", "superseded"].includes(record?.status)) return false;
   const matches = (revision) => revisionsMatch("applicability-scope", review.scopeRevision, revision);
   if (matches(applicabilityScopeRevision(record, program, resources, model))) return true;
+  if (Number(model.modelVersion) >= 11 && applicabilityDecisionFields[record?.type]
+    && matches(applicabilityScopeRevision(record, program, resources, model, { legacyResourceProjection: true }))) return true;
   if (["commitment", "control", "complementary-control"].includes(record?.type) && matches(applicabilityScopeRevision(
     record, program, resources, model, { legacyBroadScope: true }
   ))) return true;
-  if (["commitment", "control", "complementary-control"].includes(record?.type) && root && historicalScopedReviewMatches(
+  if (Number(model.modelVersion) >= 11 && applicabilityDecisionFields[record?.type] && root && historicalScopedReviewMatches(
     review.scopeRevision, record, program, resources, model, root
   )) return true;
   // Older reviews hashed Policy approval metadata alongside scope facts.
@@ -243,8 +269,13 @@ export function applicabilityReviewIsCurrent(review, record, program, resources,
 
 function historicalScopedReviewMatches(stored, record, program, resources, model, root) {
   const current = applicabilityScopeRevision(record, program, resources, model);
-  for (const commit of getDataCommitHistory(root).reverse()) {
-    const snapshot = historicalWorkspace(root, commit);
+  const context = reviewHistoryContext(root, resources);
+  const { index } = context;
+  const commits = index?.available
+    ? reviewCommitsChangingTypes(index, scopeSourceTypes)
+    : reviewHistoryCommits(context);
+  for (const commit of [...commits].reverse()) {
+    const snapshot = reviewHistoricalWorkspace(context, commit);
     if (!snapshot) continue;
     const historicalResources = snapshot.resources;
     const historicalRecord = historicalResources.find(({ id }) => id === record.id);
@@ -254,9 +285,14 @@ function historicalScopedReviewMatches(stored, record, program, resources, model
     if (!revisionsMatch("applicability-scope", current, applicabilityScopeRevision(
       historicalRecord, historicalProgram, historicalResources, historicalModel
     ))) continue;
-    if (revisionsMatch("applicability-scope", stored, applicabilityScopeRevision(
-      historicalRecord, historicalProgram, historicalResources, historicalModel, { legacyBroadScope: true }
-    ))) return true;
+    for (const legacyBroadScope of [false, true]) {
+      for (const legacyResourceProjection of [false, true]) {
+        if (revisionsMatch("applicability-scope", stored, applicabilityScopeRevision(
+          historicalRecord, historicalProgram, historicalResources, historicalModel,
+          { legacyBroadScope, legacyResourceProjection }
+        ))) return true;
+      }
+    }
   }
   return false;
 }

package/src/batch-review.js

@@ -142,16 +142,23 @@ function planApplicabilityReviewWithContext(context, options) {
       }
     : program;
   const update = reviewedDecisions.flatMap(({ record, result, rationale, reviewedByIds, reviewedOn }) => {
-    const scopeRevision = applicabilityScopeRevision(record, reviewedProgram, loaded.resources, loaded.model);
-    const next = {
-      ...record,
-      applicabilityReview: {
-        decision: result,
-        rationale,
-        reviewedByIds,
-        reviewedOn,
-        scopeRevision
+    const next = { ...record };
+    if (record.type === "control" && result === "not-applicable" && record.status !== "not-applicable") {
+      next.status = "not-applicable";
+      if (loaded.model.resources.control.fields.statusTransition) {
+        next.statusTransition = { changedByIds: reviewedByIds, changedOn: reviewedOn, reason: rationale };
       }
+    }
+    if (record.type === "control" && result !== "not-applicable" && record.status === "not-applicable") {
+      next.status = "planned";
+      delete next.statusTransition;
+    }
+    next.applicabilityReview = {
+      decision: result,
+      rationale,
+      reviewedByIds,
+      reviewedOn,
+      scopeRevision: applicabilityScopeRevision(next, reviewedProgram, loaded.resources, loaded.model)
     };
     if (record.type === "requirement") {
       if (modelSupports(loaded.model, "program-scope")) {
@@ -160,8 +167,6 @@ function planApplicabilityReviewWithContext(context, options) {
       next.applicability = result;
       next.applicabilityRationale = rationale;
     }
-    if (record.type === "control" && result === "not-applicable") next.status = "not-applicable";
-    if (record.type === "control" && result === "applicable" && record.status === "not-applicable") next.status = "planned";
     return [next];
   });
   if (v4RequirementDecisions.length) {

package/src/collection-revision.js

@@ -7,8 +7,8 @@ import {
   collectionScopeRevisionFacts
 } from "./collection-scope.js";
 import { resolveDataPath } from "./paths.js";
-import { getDataCommitHistory, getFileAtRevision } from "./git.js";
-import { historicalWorkspace } from "./historical-workspace.js";
+import { getFileAtRevision } from "./git.js";
+import { reviewHistoricalWorkspace, reviewHistoryCommits, reviewHistoryContext } from "./historical-workspace.js";
 import { resolveProgram } from "./program.js";
 import { markdownEntries } from "./resource-markdown.js";
 import { CALCULATED_REVISION_FIELDS, CALCULATED_REVISION_MAP_FIELDS, calculateRevision, canonicalCalculatedRevision, revisionsMatch } from "./revisions.js";
@@ -46,8 +46,9 @@ export function collectionRevisionMatches(loaded, resourceType, storedRevision,
 
 function historicallyEquivalentCollection(loaded, resourceType, stored, options, current) {
   if (!loaded.root) return false;
-  for (const commit of getDataCommitHistory(loaded.root).reverse()) {
-    const snapshot = historicalWorkspace(loaded.root, commit);
+  const context = reviewHistoryContext(loaded.root, loaded);
+  for (const commit of [...reviewHistoryCommits(context)].reverse()) {
+    const snapshot = reviewHistoricalWorkspace(context, commit);
     if (!snapshot) continue;
     const historicalOptions = {
       ...options,
@@ -103,7 +104,9 @@ function calculateCollectionRevision(loaded, resourceType, options, legacy, scop
       contentRevisions: (legacy || includeContent ? markdownEntries(loaded.model, record) : []).flatMap(({ path }) => {
         try {
           const content = options.historicalCommit
-            ? getFileAtRevision(loaded.root, options.historicalCommit, `data/${path}`)
+            ? loaded.historicalFiles
+              ? loaded.historicalFiles.get(`data/${path}`) ?? null
+              : getFileAtRevision(loaded.root, options.historicalCommit, `data/${path}`)
             : readFileSync(resolveDataPath(loaded.root, path), "utf8");
           if (content === null) return [];
           return [{ path, revision: createHash("sha256").update(content).digest("hex") }];

package/src/collection-scope.js

@@ -200,6 +200,7 @@ function scopedProgramPeople(loaded, program = {}) {
 
 export function collectionRevisionInputs(loaded, resourceType, program, options = {}) {
   const legacy = options.legacy === true;
+  const currentModel = modelSupports(loaded.model, "retention-schedule-approval");
   const reviewed = scopedCollectionRecords(loaded, resourceType, program);
   if (!modelSupports(loaded.model, "program-scope")) {
     return reviewed.map((record) => ({ record, value: record, includeContent: true }));
@@ -367,11 +368,11 @@ export function collectionRevisionInputs(loaded, resourceType, program, options
         && record.type === "document"
           ? retentionScheduleDocumentProposalValue(record)
           : options.historicalReviewMetadata
-            ? dependencyRevisionValue(resourceType, record, legacy)
-            : substantiveRevisionValue(dependencyRevisionValue(resourceType, record, legacy)),
+            ? dependencyRevisionValue(resourceType, record, legacy, true, currentModel)
+            : substantiveRevisionValue(dependencyRevisionValue(resourceType, record, legacy, false, currentModel)),
     includeContent: legacy
       || reviewedIds.has(record.id)
-      || dependencyContentAffectsRevision(resourceType, record.type)
+      || dependencyContentAffectsRevision(resourceType, record.type, options.historicalReviewMetadata, currentModel)
   }));
 }
 
@@ -379,7 +380,7 @@ function retentionScheduleRowProposalValue(record, historicalReviewMetadata = fa
   return Object.fromEntries(Object.entries(record).filter(([field]) => ![
     "approvedByIds",
     "approvedOn",
-    ...(historicalReviewMetadata ? [] : ["reviewedSourceRevisions"])
+    ...(historicalReviewMetadata ? [] : ["reviewedSourceRevisions", "tags", "statusTransition"])
   ].includes(field)));
 }
 
@@ -591,22 +592,31 @@ const dependencyContentTypes = {
   component: new Set(["system"]),
   control: new Set(["system", "component", "obligation", "source-coverage", "evidence", "retention-schedule-item", "document", "policy", "training"]),
   "retention-schedule-item": new Set(["document", "policy"]),
-  "complementary-control": new Set(["system", "control", "document", "component"])
+  "complementary-control": new Set(["system", "document", "component"])
 };
 
-function dependencyRevisionValue(resourceType, record, legacy) {
-  const fields = legacy
+function dependencyRevisionValue(resourceType, record, legacy, historicalReviewMetadata = false, currentModel = false) {
+  const controlDecision = currentModel && !historicalReviewMetadata && record.type === "control"
+    && ["retention-schedule-item", "complementary-control"].includes(resourceType);
+  const fields = controlDecision
+    ? resourceType === "retention-schedule-item"
+      ? ["id", "type", "statement", "activity", "controlType", "operationMode", "operationPattern", "requirementIds", "systemIds", "policyIds", "componentIds", "evidenceSourceComponentIds"]
+      : ["id", "type", "statement", "activity", "controlType", "operationMode", "operationPattern", "requirementIds", "systemIds", "policyIds", "componentIds", "evidenceSourceComponentIds"]
+    : legacy
     ? legacyDependencyFieldOverrides[resourceType]?.[record.type]
       || dependencyFields[resourceType]?.[record.type]
     : dependencyFields[resourceType]?.[record.type];
   if (!fields) return { id: record.id, type: record.type };
-  return Object.fromEntries(fields
+  const value = Object.fromEntries(fields
     .filter((field) => record[field] !== undefined)
     .map((field) => [field, record[field]]));
+  if (controlDecision) value.unavailable = ["not-applicable", "retired", "superseded"].includes(record.status);
+  return value;
 }
 
-function dependencyContentAffectsRevision(resourceType, dependencyType) {
-  return dependencyContentTypes[resourceType]?.has(dependencyType) || false;
+function dependencyContentAffectsRevision(resourceType, dependencyType, historicalReviewMetadata = false, currentModel = false) {
+  return ((!currentModel || historicalReviewMetadata) && resourceType === "complementary-control" && dependencyType === "control")
+    || dependencyContentTypes[resourceType]?.has(dependencyType) || false;
 }
 
 function sorted(values) {

package/src/historical-workspace.js

@@ -1,10 +1,55 @@
 import { loadModel } from "../model/index.js";
-import { getDataFilesAtRevision, getFileAtRevision } from "./git.js";
+import { getDataCommitHistory, getDataFilesAtRevision, getDataRecordHistoryIndex, getFileAtRevision } from "./git.js";
+import { performance } from "node:perf_hooks";
 
-// Rebuild only the authoritative data needed for a historical revision check.
-// The caller must compare current and historical facts before accepting a
-// legacy binding; this snapshot never supplies a new approval.
-export function historicalWorkspace(root, commit) {
+const reviewContexts = new WeakMap();
+
+export function reviewHistoryContext(root, owner) {
+  const key = owner.resources || owner;
+  let context = reviewContexts.get(key);
+  if (context) return context;
+  let index = null;
+  try {
+    // Leave time for the original Git recovery path if this larger index
+    // cannot be built within a browser request.
+    index = getDataRecordHistoryIndex(root, { deadline: performance.now() + 3_000 });
+  } catch (error) {
+    if (error.code !== "FILEGRC_HISTORY_DEADLINE") throw error;
+  }
+  context = { root, index, statesByCommit: new Map(), workspacesByCommit: new Map() };
+  reviewContexts.set(key, context);
+  return context;
+}
+
+export function reviewHistoryCommits(context) {
+  if (context.index?.available) return context.index.commits;
+  context.fallbackCommits ||= getDataCommitHistory(context.root);
+  return context.fallbackCommits;
+}
+
+export function reviewCommitsChangingTypes(index, types) {
+  const paths = new Set();
+  for (const records of index.recordsByCommit.values()) {
+    for (const { record, path } of records.values()) {
+      if (types.has(record.type)) paths.add(path);
+    }
+  }
+  return index.commits.filter((commit) => [...(index.fileChangesByCommit.get(commit)?.keys() || [])]
+    .some((path) => paths.has(path)));
+}
+
+export function reviewHistoricalWorkspace(context, commit) {
+  if (context.index?.available) return indexedHistoricalWorkspace(context, commit);
+  if (context.workspacesByCommit.has(commit)) return context.workspacesByCommit.get(commit);
+  const loaded = historicalWorkspace(context.root, commit);
+  context.workspacesByCommit.set(commit, loaded);
+  if (context.workspacesByCommit.size > 128) context.workspacesByCommit.delete(context.workspacesByCommit.keys().next().value);
+  return loaded;
+}
+
+// Preserve recovery beyond the reconciliation index's size and build limits.
+// It is slower, but still requires the same substantive comparison.
+function historicalWorkspace(root, commit) {
   const entries = [];
   for (const path of getDataFilesAtRevision(root, commit).filter(authoritativeJsonPath)) {
     const source = getFileAtRevision(root, commit, path);
@@ -25,6 +70,59 @@ export function historicalWorkspace(root, commit) {
   }
 }
 
+// The history index already contains every committed JSON and Markdown source.
+// Materialize its first-parent states once instead of asking Git to list and
+// read the entire workspace for every legacy review binding.
+export function indexedHistoricalWorkspace(context, commit) {
+  const { root, index } = context;
+  if (!index?.available || !index.parentsByCommit.has(commit)) return null;
+  // Reuse a full request-sized history for ordinary workspaces while bounding
+  // retained maps when a repository contains many thousands of data files.
+  const cacheLimit = Math.max(1, Math.min(512, Math.floor(200_000 / Math.max(1, index.historicalRecordPaths.size))));
+  if (context.workspacesByCommit.has(commit)) return context.workspacesByCommit.get(commit);
+  let state = context.statesByCommit.get(commit);
+  if (!state) {
+    const lineage = [];
+    let cursor = commit;
+    while (cursor && !context.statesByCommit.has(cursor)) {
+      lineage.push(cursor);
+      cursor = index.parentsByCommit.get(cursor)?.[0] || null;
+    }
+    state = cursor ? context.statesByCommit.get(cursor) : new Map();
+    for (let position = lineage.length - 1; position >= 0; position -= 1) {
+      const changedAt = lineage[position];
+      const next = new Map(state);
+      for (const [path, source] of index.fileChangesByCommit.get(changedAt) || []) {
+        if (source === null) next.delete(path);
+        else next.set(path, source);
+      }
+      context.statesByCommit.set(changedAt, next);
+      if (context.statesByCommit.size > cacheLimit) context.statesByCommit.delete(context.statesByCommit.keys().next().value);
+      state = next;
+    }
+  }
+  const entries = [];
+  for (const [path, source] of state) {
+    if (!authoritativeJsonPath(path)) continue;
+    try {
+      entries.push({ record: JSON.parse(source), source, relativePath: path.slice("data/".length) });
+    } catch {
+      return null;
+    }
+  }
+  const resources = entries.map(({ record }) => record);
+  const workspace = resources.find(({ type }) => type === "workspace");
+  if (!workspace) return null;
+  try {
+    const loaded = { root, entries, resources, workspace, model: loadModel(workspace.dataModelVersion), historicalFiles: state };
+    context.workspacesByCommit.set(commit, loaded);
+    if (context.workspacesByCommit.size > cacheLimit) context.workspacesByCommit.delete(context.workspacesByCommit.keys().next().value);
+    return loaded;
+  } catch {
+    return null;
+  }
+}
+
 function authoritativeJsonPath(path) {
   const parts = path.split("/");
   if (parts[0] !== "data" || !path.endsWith(".json")) return false;

package/src/retention.js

@@ -6,8 +6,8 @@ import { programComponents } from "./program.js";
 import { markdownEntries } from "./resource-markdown.js";
 import { modelSupports } from "../model/index.js";
 import { canonicalCalculatedRevisionJson, revisionDigest, revisionsMatch } from "./revisions.js";
-import { getDataCommitHistory, getFileAtRevision } from "./git.js";
-import { historicalWorkspace } from "./historical-workspace.js";
+import { getFileAtRevision } from "./git.js";
+import { reviewHistoricalWorkspace, reviewHistoryCommits, reviewHistoryContext } from "./historical-workspace.js";
 
 export async function assessRetentionReadiness(loaded, program, options = {}) {
   if (!loaded.model.resources["retention-schedule-item"]) return [];
@@ -167,7 +167,7 @@ export async function resourceReviewRevisions(loaded, ids, scopeHashInput = "leg
     if (!entry || reviewing.has(id)) return null;
     reviewing.add(id);
     const parts = [reviewSource(loaded, entry, scopeHashInput)];
-    for (const markdown of markdownEntries(loaded.model, entry.record)) {
+    for (const markdown of reviewMarkdownEntries(loaded, entry, false)) {
       try {
         parts.push(await readFile(resolveDataPath(loaded.root, markdown.path), "utf8"));
       } catch (error) {
@@ -200,10 +200,12 @@ export function resourceReviewRevisionsSync(loaded, ids, scopeHashInput = "legac
     if (!entry || reviewing.has(id)) return null;
     reviewing.add(id);
     const parts = [reviewSource(loaded, entry, scopeHashInput, legacySource)];
-    for (const markdown of markdownEntries(loaded.model, entry.record)) {
+    for (const markdown of reviewMarkdownEntries(loaded, entry, legacySource)) {
       try {
         const source = historicalCommit
-          ? getFileAtRevision(loaded.root, historicalCommit, `data/${markdown.path}`)
+          ? loaded.historicalFiles
+            ? loaded.historicalFiles.get(`data/${markdown.path}`) ?? null
+            : getFileAtRevision(loaded.root, historicalCommit, `data/${markdown.path}`)
           : readFileSync(resolveDataPath(loaded.root, markdown.path), "utf8");
         if (source !== null) parts.push(source);
       } catch (error) {
@@ -241,8 +243,24 @@ export function resourceReviewRevisionMatches(loaded, revisions, id, stored) {
 // records and Markdown, before the old approval is treated as current.
 function historicallyEquivalentReviewSource(loaded, id, stored, current) {
   if (!loaded.root) return false;
-  for (const commit of getDataCommitHistory(loaded.root).reverse()) {
-    const snapshot = historicalWorkspace(loaded.root, commit);
+  const context = reviewHistoryContext(loaded.root, loaded);
+  const { index } = context;
+  const relevantPaths = index?.available ? new Set(["data/workspace.json"]) : null;
+  const graphIds = new Set();
+  const visit = (resourceId) => {
+    if (graphIds.has(resourceId)) return;
+    graphIds.add(resourceId);
+    const entry = loaded.entries.find(({ record }) => record.id === resourceId);
+    if (!entry) return;
+    for (const path of (index.historiesById.get(resourceId) || []).map(({ path }) => path)) relevantPaths.add(path);
+    for (const markdown of markdownEntries(loaded.model, entry.record)) relevantPaths.add(`data/${markdown.path}`);
+    for (const sourceId of entry.record.sourceResourceIds || []) visit(sourceId);
+  };
+  if (relevantPaths) visit(id);
+  for (const commit of [...reviewHistoryCommits(context)].reverse()) {
+    const changed = index?.available ? index.fileChangesByCommit.get(commit) : null;
+    if (relevantPaths && ![...changed.keys()].some((path) => relevantPaths.has(path) || path.endsWith(".md"))) continue;
+    const snapshot = reviewHistoricalWorkspace(context, commit);
     if (!snapshot?.entries.some(({ record }) => record.id === id)) continue;
     const semantic = resourceReviewRevisionsSync(snapshot, [id], "legacy", false, commit).get(id);
     if (!revisionsMatch("content", semantic, current)) continue;
@@ -299,10 +317,52 @@ function reviewSource(loaded, entry, scopeHashInput = "legacy", legacySource = f
   }
   return legacySource
     ? canonicalCalculatedRevisionJson(entry.source, scopeHashInput)
-    : canonicalCalculatedRevisionJson(JSON.stringify(substantiveReviewSource(JSON.parse(entry.source))), scopeHashInput);
+    : canonicalCalculatedRevisionJson(JSON.stringify(substantiveReviewSource(
+      JSON.parse(entry.source), modelSupports(loaded.model, "retention-schedule-approval")
+    )), scopeHashInput);
+}
+
+function reviewMarkdownEntries(loaded, entry, legacySource) {
+  // Control Markdown records the implementation procedure. Retention and
+  // mapping decisions depend on the structured Control design instead.
+  if (!legacySource && modelSupports(loaded.model, "retention-schedule-approval")
+    && entry.record.type === "control") return [];
+  return markdownEntries(loaded.model, entry.record);
 }
 
-function substantiveReviewSource(record) {
+const reviewDecisionFields = {
+  control: ["statement", "requirementIds", "code", "activity", "controlType", "operationMode", "operationPattern", "systemIds", "policyIds", "componentIds", "evidenceSourceComponentIds"],
+  commitment: ["commitmentKind", "statement", "systemIds", "sourceResourceIds", "requirementIds", "controlIds", "customerFacing", "effectiveOn", "reportingRouteRequirements"],
+  "complementary-control": ["responsibleParty", "statement", "systemIds", "vendorId", "requirementIds", "commitmentIds", "relatedControlIds", "sourceDocumentIds", "componentIds"],
+  "source-coverage": ["sourceFamilyId", "coverageKind", "scopeResourceIds", "excludedPopulation", "collectionCadence", "reconciliationMethod", "validFrom", "validThrough", "componentId", "retentionScheduleItemIds"],
+  system: ["purpose", "servicesProvided", "boundary", "exclusions", "criticality", "informationTypeIds", "classificationId", "internetExposed", "continuityObjectives"],
+  component: ["componentKind", "description", "criticality", "environment", "vendorId", "systemUses", "informationUses", "evidenceSourceKinds", "internetExposed", "classificationId", "continuityObjectives"],
+  vendor: ["category", "criticality", "description", "standardAgreement", "agreementDocumentId", "startDate", "endDate", "informationTypeIds", "classificationId"],
+  "information-type": ["classificationId", "description"],
+  framework: ["version", "publisher", "description", "sourceReference", "effectiveOn"],
+  requirement: ["frameworkId", "reference", "description", "parentRequirementId"],
+  policy: ["policyNumber", "policyKind", "version", "effectiveOn", "supersedesId", "parentPolicyId", "relatedPolicyIds", "relatedDocumentIds", "requirementIds", "audience", "acknowledgementRequired", "programRole", "reportingRouteRequirements"],
+  document: ["documentKind", "workflowScope", "template", "version", "effectiveOn", "supersedesId", "systemIds", "controlIds", "relatedDocumentIds", "audience", "acknowledgementRequired", "trainingIds", "classificationId", "programRole", "componentIds", "reportingRouteRequirements"]
+};
+
+function substantiveReviewSource(record, currentModel) {
+  if (currentModel && reviewDecisionFields[record.type]) {
+    const fields = ["id", "type", "title", "extensions", "externalIds", ...reviewDecisionFields[record.type]];
+    const decision = Object.fromEntries(fields.filter((field) => record[field] !== undefined)
+      .map((field) => [field, record[field]]));
+    if (record.type === "control") {
+      decision.unavailable = ["not-applicable", "retired", "superseded"].includes(record.status);
+    } else if (["policy", "document"].includes(record.type)) {
+      decision.governingStatus = ["approved", "active"].includes(record.status) ? "approved" : record.status || null;
+    } else {
+      decision.status = record.status || null;
+    }
+    if (["control", "commitment", "complementary-control"].includes(record.type)) {
+      decision.nonApplicableDecision = ["not-applicable", "externally-managed", "zero-population"]
+        .includes(record.applicabilityReview?.decision) ? record.applicabilityReview.decision : null;
+    }
+    return decision;
+  }
   const source = record.type === "program" ? {
     id: record.id,
     type: record.type,