@taprootio/site-authoring 0.14.1 → 0.15.0

package/src/verbs/validate.js

@@ -2,8 +2,9 @@ import { lstat, realpath } from "node:fs/promises";
 import path from "node:path";
 
 import { NAVIGATION_MAXIMUM_DEPTH } from "../api.js";
+import { loadSiteConfig } from "../config.js";
 import { VERB_VALIDATE } from "../constants.js";
-import { freeFormRootPresentation, sharedThemeContextNames } from "../content/free-form-sections.js";
+import { freeFormRootPresentation } from "../content/free-form-sections.js";
 import { isCanonicalUuid, SiteAuthoringError } from "../errors.js";
 import {
   FIXTURE_CONTRACT_VERSION,
@@ -14,42 +15,32 @@ import {
   FIXTURE_ROOT_FIELDS,
 } from "../fixture-contract.js";
 import { initializeFixture } from "../fixture-init.js";
-import { appearanceManifestEntry, FOOTER_SETTINGS_FILE, footerManifestEntry } from "../footer-workspace.js";
-import { readWorkspaceForms } from "../forms-workspace.js";
+import { appearanceManifestEntry, footerManifestEntry } from "../footer-workspace.js";
 import { FORMS_DIRECTORY } from "../forms-contract.js";
-import {
-  isRedirectMapRevision,
-  normalizeRedirectPath,
-  REDIRECT_KIND_GONE,
-  REDIRECTS_FILE_NAME,
-  validateRedirectsDocument,
-} from "../redirects-contract.js";
+import { CHECK_AREA, collectProblems, refuseProblems } from "../problems.js";
+import { isRedirectMapRevision, REDIRECT_KIND_GONE, REDIRECTS_FILE_NAME } from "../redirects-contract.js";
 import { boundedList, successResult } from "../session.js";
-import { SETTINGS_GROUPS, SETTINGS_TYPE_SITE_PUBLISHING_PREFERENCES } from "../settings-catalog.js";
+import { SETTINGS_GROUPS } from "../settings-catalog.js";
+import { checkWorkspace } from "../workspace-check.js";
 import {
+  MANIFEST_FILE_NAME,
   MANIFEST_VERSION,
+  MEDIA_MANIFEST_FILE_NAME,
   NAVIGATION_FILE_NAME,
   normalizePagePath,
   PAGE_SOURCE_EXTENSIONS,
   PAGE_WORKSPACE_MODE_EDITABLE,
   PAGES_DIRECTORY,
   pageSourceFormat,
+  readManifest,
+  readMediaManifest,
   readWorkspaceJson,
   SETTINGS_DIRECTORY,
   walkWorkspaceFiles,
   WORKSPACE_LIMITS,
+  workspaceFileExists,
 } from "../workspace.js";
-import { validateFooterWorkspaceDocument } from "./footer-push.js";
-import { validateNavigationWorkspaceDocument } from "./nav-push.js";
-import { validateWorkspacePageDocument, validateWorkspacePageSource } from "./pages-push.js";
-import { validateThemeWorkspace } from "./theme-push.js";
-import {
-  documentImageIds,
-  documentTemplate,
-  isAuthorableTemplateType,
-  PAGE_TEMPLATES,
-  placedVideoIds,
-} from "../typed-pages.js";
+import { documentImageIds, isAuthorableTemplateType, placedVideoIds } from "../typed-pages.js";
 
 const MAXIMUM_REPORTED = 200;
 const FIXTURE_ROOT_KEYS = new Set(FIXTURE_ROOT_FIELDS);
@@ -436,10 +427,8 @@ function headerWidthHints(headerWidth, rootBandPages) {
  * The fixture's forms, when it carries any. The manifest binding and the files
  * must name the same keys: a form file the manifest does not mention would be
  * validated by no one, and a key with no file would be a baseline for nothing.
- * Returns undefined for a fixture with no forms.
  */
-async function validateFixtureForms(fixtureRoot, bound, onProgress) {
-  const files = await readWorkspaceForms(fixtureRoot);
+function requireFixtureFormsBound(bound, files) {
   if (bound === undefined) {
     if (files.length > 0) {
       fail(
@@ -448,7 +437,7 @@ async function validateFixtureForms(fixtureRoot, bound, onProgress) {
         "forms",
       );
     }
-    return undefined;
+    return;
   }
   const items = isPlainObject(bound) && isPlainObject(bound.items) ? bound.items : undefined;
   const keys = items === undefined ? [] : Object.keys(items).sort();
@@ -479,163 +468,95 @@ async function validateFixtureForms(fixtureRoot, bound, onProgress) {
       "forms",
     );
   }
-  onProgress(`Validated ${files.length} form file${files.length === 1 ? "" : "s"} against the shared field schema.`);
-  return files;
 }
 
-export async function validateFixture(invocation = {}) {
-  if (invocation.init) return await initializeFixture(invocation, validateFixture);
-  const onProgress = typeof invocation.onProgress === "function" ? invocation.onProgress : () => {};
-  const fixtureRoot = await resolveFixtureRoot(invocation.cwd ?? process.cwd(), invocation.fixturePath);
-  onProgress(`Reading ${FIXTURE_MANIFEST_FILE_NAME}.`);
-  const contract = validateFixtureManifest(
-    await readWorkspaceJson(fixtureRoot, FIXTURE_MANIFEST_FILE_NAME, WORKSPACE_LIMITS.manifestBytes),
-  );
-  const {
-    manifest,
-    imageIds,
-    videoIds,
-    deliveryOrigins,
-    pageIds,
-    resourceIds,
-    files: declaredFiles,
-    settingsEntityIds,
-  } = contract;
-
-  onProgress("Validating the complete light/dark theme, appearance, header, brand, and footer colors.");
-  const presentation = await validateThemeWorkspace(fixtureRoot, manifest.siteId, imageIds, settingsEntityIds);
-  const expectedAppearance = appearanceManifestEntry({
-    SETTING_TYPE_TAPROOT_STYLES: presentation.style,
-    SETTING_TYPE_BRAND: presentation.brand,
-    SETTING_TYPE_SITE_HEADER: presentation.header,
-  });
-  if (manifest.appearance !== undefined && JSON.stringify(manifest.appearance) !== JSON.stringify(expectedAppearance)) {
-    fail(
-      "fixture.appearance_invalid",
-      "The fixture appearance metadata must match its settings image identities.",
-      "appearance",
-    );
-  }
-  if (manifest.footer !== undefined) {
-    const expectedFooter = footerManifestEntry(presentation.publishing.footerSettings);
-    if (
-      !isPlainObject(manifest.footer) || Object.keys(manifest.footer).length !== Object.keys(expectedFooter).length
-      || Object.entries(expectedFooter).some(([key, value]) =>
-        JSON.stringify(manifest.footer[key]) !== JSON.stringify(value)
-      )
-    ) {
-      fail("fixture.footer_invalid", "The fixture footer metadata must match its footer document.", "footer");
-    }
-  }
-  for (const warning of presentation.themes.warnings) onProgress(`Espalier warning: ${warning}`);
-  if (presentation.themes.warningsTruncated) {
-    const hidden = presentation.themes.warningCount - presentation.themes.warnings.length;
-    onProgress(`${hidden} more Espalier warning(s) not shown; resolve the ones above and run validate again to see them.`);
-  }
-  const sharedContexts = sharedThemeContextNames(
-    presentation.style.lightTheme,
-    presentation.style.darkTheme,
-  );
-
+/** Every editable page source on disk, each one bound by the fixture manifest. */
+async function fixturePageFileProblems(fixtureRoot, declaredFiles) {
+  const problems = [];
   const pageFiles = await walkWorkspaceFiles(fixtureRoot, PAGES_DIRECTORY, PAGE_SOURCE_EXTENSIONS);
-  const manifestByFile = new Map(manifest.pages.map((entry) => [entry.file, entry]));
   for (const file of declaredFiles) {
-    if (!pageFiles.includes(file)) {
-      fail("fixture.page_missing", `The fixture manifest binds missing page source '${file}'.`, file);
-    }
+    if (pageFiles.includes(file)) continue;
+    await collectProblems(problems, { area: CHECK_AREA.pages, file }, () =>
+      fail("fixture.page_missing", `The fixture manifest binds missing page source '${file}'.`, file));
+  }
+  for (const file of pageFiles.filter((candidate) => !declaredFiles.has(candidate))) {
+    await collectProblems(problems, { area: CHECK_AREA.pages, file }, () =>
+      fail("fixture.page_untracked", `Page source '${file}' is not bound by ${FIXTURE_MANIFEST_FILE_NAME}.`, file));
   }
-  const untracked = pageFiles.find((file) => !declaredFiles.has(file));
-  if (untracked !== undefined) {
+  return problems;
+}
+
+/**
+ * What only a fixture promises about a page that passed the shared checks:
+ * its source declares the path its manifest entry binds, and every image and
+ * video it places is one the fixture declares.
+ */
+function requireFixturePageBound(page, entry, { imageIds, videoIds, deliveryOrigins }) {
+  const { file, document: document_ } = page;
+  if (page.pagePath !== normalizePagePath(entry.path)) {
     fail(
-      "fixture.page_untracked",
-      `Page source '${untracked}' is not bound by ${FIXTURE_MANIFEST_FILE_NAME}.`,
-      untracked,
+      "fixture.page_path_mismatch",
+      `'${file}' declares path '${page.pagePath}' but its fixture manifest entry binds '${entry.path}'.`,
+      file,
     );
   }
-  const validatedPages = [];
-  const rootBandPages = [];
-  for (const file of pageFiles) {
-    onProgress(`Validating '${file}'.`);
-    const entry = manifestByFile.get(file);
-    const page = await validateWorkspacePageSource({
-      workspaceDir: fixtureRoot,
+  validatePageImageReferences(document_, file, imageIds, deliveryOrigins);
+  // Album images and the cover image are bare ids with no delivery URL, so
+  // the walk above cannot see them.
+  const unknownImage = documentImageIds(document_).find((imageId) => !imageIds.has(imageId));
+  if (unknownImage !== undefined) {
+    fail(
+      "fixture.image_reference_unknown",
+      `Fixture image '${unknownImage}' is not declared in fixture.imageIds.`,
       file,
-      manifestEntry: entry,
-      mediaManifest: { media: {} },
-      content: invocation.content,
-    });
-    await validateWorkspacePageDocument({
-      workspaceDir: fixtureRoot,
-      siteId: manifest.siteId,
+    );
+  }
+  const unknownVideo = [...placedVideoIds(document_)].find((videoId) => !videoIds.has(videoId));
+  if (unknownVideo !== undefined) {
+    fail(
+      "fixture.video_reference_unknown",
+      `Fixture video '${unknownVideo}' is not declared in fixture.videoIds, so it is not a ready video of this site.`,
       file,
-      document: page.document,
-      content: invocation.content,
-      getSharedThemeContexts: async () => sharedContexts,
+    );
+  }
+}
+
+/** The fixture manifest's own records of the presentation, navigation, and redirects it binds. */
+function requireFixtureRecordsMatch(manifest, checked) {
+  const { presentation, navigation, redirects } = checked;
+  if (presentation !== undefined) {
+    const expectedAppearance = appearanceManifestEntry({
+      SETTING_TYPE_TAPROOT_STYLES: presentation.style,
+      SETTING_TYPE_BRAND: presentation.brand,
+      SETTING_TYPE_SITE_HEADER: presentation.header,
     });
-    if (page.pagePath !== normalizePagePath(entry.path)) {
-      fail(
-        "fixture.page_path_mismatch",
-        `'${file}' declares path '${page.pagePath}' but its fixture manifest entry binds '${entry.path}'.`,
-        file,
-      );
-    }
-    // The manifest states which template the page has, and the source must be
-    // one: a recipe document bound as an article would push as the wrong type.
-    if (PAGE_TEMPLATES[documentTemplate(page.document)].wireType !== entry.templateType) {
-      fail(
-        "fixture.page_template_mismatch",
-        `'${file}' is a ${documentTemplate(page.document)} source, but its fixture manifest entry binds `
-          + `${entry.templateType}.`,
-        file,
-      );
-    }
-    validatePageImageReferences(page.document, file, imageIds, deliveryOrigins);
-    // Album images and the cover image are bare ids with no delivery URL, so
-    // the walk above cannot see them.
-    const unknownImage = documentImageIds(page.document).find((imageId) => !imageIds.has(imageId));
-    if (unknownImage !== undefined) {
+    if (manifest.appearance !== undefined && JSON.stringify(manifest.appearance) !== JSON.stringify(expectedAppearance)) {
       fail(
-        "fixture.image_reference_unknown",
-        `Fixture image '${unknownImage}' is not declared in fixture.imageIds.`,
-        file,
+        "fixture.appearance_invalid",
+        "The fixture appearance metadata must match its settings image identities.",
+        "appearance",
       );
     }
-    const unknownVideo = [...placedVideoIds(page.document)].find((videoId) => !videoIds.has(videoId));
-    if (unknownVideo !== undefined) {
-      fail(
-        "fixture.video_reference_unknown",
-        `Fixture video '${unknownVideo}' is not declared in fixture.videoIds, so it is not a ready video of this site.`,
-        file,
-      );
+    if (manifest.footer !== undefined) {
+      const expectedFooter = footerManifestEntry(presentation.publishing.footerSettings);
+      if (
+        !isPlainObject(manifest.footer) || Object.keys(manifest.footer).length !== Object.keys(expectedFooter).length
+        || Object.entries(expectedFooter).some(([key, value]) =>
+          JSON.stringify(manifest.footer[key]) !== JSON.stringify(value)
+        )
+      ) {
+        fail("fixture.footer_invalid", "The fixture footer metadata must match its footer document.", "footer");
+      }
     }
-    validatedPages.push({ file, path: page.pagePath });
-    if (pageUsesRootBand(page.document)) rootBandPages.push(file);
   }
-  const hints = headerWidthHints(presentation.header.headerWidth, rootBandPages);
-  for (const hint of hints) onProgress(`Hint: ${hint.message}`);
-
-  onProgress("Validating navigation shape and local PAGE targets.");
-  const navigation = validateNavigationWorkspaceDocument(
-    await readWorkspaceJson(fixtureRoot, NAVIGATION_FILE_NAME, WORKSPACE_LIMITS.navigationBytes),
-    manifest.siteId,
-    { pageIds, resourceIds },
-  );
-  if (navigation.items !== manifest.navigation.items) {
+  if (navigation !== undefined && navigation.items !== manifest.navigation.items) {
     fail(
       "fixture.navigation_count_mismatch",
       `${NAVIGATION_FILE_NAME} contains ${navigation.items} item(s), but the fixture manifest records ${manifest.navigation.items}.`,
       "navigation.items",
     );
   }
-
-  onProgress("Validating the redirect map: paths, targets, statuses, chains, and loops.");
-  const redirectsDocument = await readWorkspaceJson(
-    fixtureRoot,
-    REDIRECTS_FILE_NAME,
-    WORKSPACE_LIMITS.redirectsBytes,
-  );
-  const redirects = validateRedirectsDocument(redirectsDocument, manifest.siteId);
-  if (redirects.entries.length !== manifest.redirects.entries) {
+  if (redirects !== undefined && redirects.entries.length !== manifest.redirects.entries) {
     fail(
       "fixture.redirects_count_mismatch",
       `${REDIRECTS_FILE_NAME} contains ${redirects.entries.length} entr${
@@ -644,51 +565,144 @@ export async function validateFixture(invocation = {}) {
       "redirects.entries",
     );
   }
-  // A fixture is self-contained, so the occupancy rule the site enforces can be
-  // checked here too: a source the fixture's own pages occupy would be refused
-  // at the API, and saying so offline is the whole point of this verb. Paths
-  // compare case-insensitively, as the site's citext path column does, and a
-  // refusal names the entry where the author wrote it: the validated map is
-  // sorted by path, so its index is not the document's.
-  const fixturePagePaths = new Set(
-    manifest.pages.map((entry) =>
-      (`/${normalizePagePath(entry.path) ?? ""}`.replace(/\/+$/u, "") || "/").toLowerCase()
-    ),
-  );
-  const authoredIndexByPath = new Map();
-  for (const [index, entry] of redirectsDocument.entries.entries()) {
-    const path = normalizeRedirectPath(entry?.path);
-    if (path !== undefined && !authoredIndexByPath.has(path.toLowerCase())) {
-      authoredIndexByPath.set(path.toLowerCase(), index);
-    }
+}
+
+function reportThemeWarnings(presentation, onProgress) {
+  if (presentation === undefined) return;
+  for (const warning of presentation.themes.warnings) onProgress(`Espalier warning: ${warning}`);
+  if (presentation.themes.warningsTruncated) {
+    const hidden = presentation.themes.warningCount - presentation.themes.warnings.length;
+    onProgress(`${hidden} more Espalier warning(s) not shown; resolve the ones above and run validate again to see them.`);
   }
-  for (const entry of redirects.entries) {
-    const key = entry.path.toLowerCase();
-    if (fixturePagePaths.has(key)) {
+}
+
+/** The part of a success result both kinds of workspace share. */
+function validatedSummary(checked, pages) {
+  const { presentation, navigation, redirects, forms } = checked;
+  const reportedPages = boundedList(pages, MAXIMUM_REPORTED);
+  return {
+    validated: {
+      ...(checked.settingsOnly ? {} : {
+        pages: {
+          total: pages.length,
+          items: reportedPages.items,
+          ...(reportedPages.truncated ? { itemsTruncated: true } : {}),
+        },
+        navigation: { items: navigation.items, maximumDepth: NAVIGATION_MAXIMUM_DEPTH },
+        ...(redirects === undefined ? {} : {
+          redirects: {
+            entries: redirects.entries.length,
+            gone: redirects.entries.filter((entry) => entry.kind === REDIRECT_KIND_GONE).length,
+          },
+        }),
+        ...(forms === undefined || forms.length === 0 ? {} : { forms: { count: forms.length } }),
+      }),
+      themes: 2,
+      appearanceSettings: presentation.scalarOperations.length,
+      footer: true,
+    },
+    warnings: {
+      items: presentation.themes.warnings,
+      count: presentation.themes.warningCount,
+      ...(presentation.themes.warningsTruncated ? { truncated: true } : {}),
+    },
+  };
+}
+
+function pageHints(checked, onProgress) {
+  if (checked.settingsOnly || checked.presentation === undefined) return [];
+  const rootBandPages = checked.pages.planned.filter((page) => pageUsesRootBand(page.document)).map((page) => page.file);
+  const hints = headerWidthHints(checked.presentation.header.headerWidth, rootBandPages);
+  for (const hint of hints) onProgress(`Hint: ${hint.message}`);
+  return hints;
+}
+
+export async function validateFixture(invocation = {}) {
+  if (invocation.init) return await initializeFixture(invocation, validateFixture);
+  const onProgress = typeof invocation.onProgress === "function" ? invocation.onProgress : () => {};
+  const cwd = invocation.cwd ?? process.cwd();
+  if (invocation.fixturePath === undefined) {
+    const config = await loadSiteConfig({ cwd, configPath: invocation.configPath });
+    if (!isCanonicalUuid(config.siteId)) {
       fail(
-        "fixture.redirect_path_occupied",
-        `Redirect source '${entry.path}' is a page in this fixture, so it cannot also be a redirect source.`,
-        `entries[${authoredIndexByPath.get(key) ?? 0}].path`,
+        "config.site_missing",
+        "No site is selected, so the workspace's identity is unknown. Run 'taproot-site use <site>' first.",
+        "siteId",
       );
     }
+    return await validatePulledWorkspace(config.workspaceDir, config.siteId, invocation, onProgress);
+  }
+  const fixtureRoot = await resolveFixtureRoot(cwd, invocation.fixturePath);
+  if (
+    !await workspaceFileExists(fixtureRoot, FIXTURE_MANIFEST_FILE_NAME)
+    && await workspaceFileExists(fixtureRoot, MANIFEST_FILE_NAME)
+  ) {
+    const { siteId } = await readWorkspaceJson(fixtureRoot, MANIFEST_FILE_NAME, WORKSPACE_LIMITS.manifestBytes);
+    if (!isCanonicalUuid(siteId)) {
+      fail("workspace.manifest_invalid", `${MANIFEST_FILE_NAME} does not record a canonical site id.`, "siteId");
+    }
+    return await validatePulledWorkspace(fixtureRoot, siteId, invocation, onProgress);
   }
 
-  onProgress("Validating the closed footer document and local page/image targets.");
-  validateFooterWorkspaceDocument(
-    await readWorkspaceJson(fixtureRoot, FOOTER_SETTINGS_FILE, WORKSPACE_LIMITS.settingsBytes),
-    manifest.siteId,
-    {
-      expectedEntityId: settingsEntityIds.get(SETTINGS_TYPE_SITE_PUBLISHING_PREFERENCES),
-      knownPageResourceIds: resourceIds,
-      knownImageIds: imageIds,
-    },
+  onProgress(`Reading ${FIXTURE_MANIFEST_FILE_NAME}.`);
+  const contract = validateFixtureManifest(
+    await readWorkspaceJson(fixtureRoot, FIXTURE_MANIFEST_FILE_NAME, WORKSPACE_LIMITS.manifestBytes),
   );
+  const { manifest, imageIds, videoIds, deliveryOrigins, pageIds, resourceIds, files: declaredFiles } = contract;
+
+  const problems = await fixturePageFileProblems(fixtureRoot, declaredFiles);
+  // The fixture's own media manifest, as in a real workspace, so Markdown media
+  // paths resolve; none means no media. One that cannot be read is a fixture
+  // problem, and its pages then resolve no media paths.
+  const mediaManifest = await collectProblems(
+    problems,
+    { area: "fixture", file: MEDIA_MANIFEST_FILE_NAME },
+    async () => {
+      try {
+        return await readMediaManifest(fixtureRoot, manifest.siteId);
+      } catch (error) {
+        if (error?.code !== "workspace.manifest_site_mismatch") throw error;
+        throw new SiteAuthoringError(
+          "fixture.media_manifest_site",
+          `The fixture's ${MEDIA_MANIFEST_FILE_NAME} must record the fixture's siteId, ${manifest.siteId}.`,
+          { field: "siteId" },
+        );
+      }
+    },
+  ) ?? { media: {} };
+  const checked = await checkWorkspace({
+    workspaceDir: fixtureRoot,
+    siteId: manifest.siteId,
+    manifest,
+    mediaManifest,
+    binding: { knownImageIds: imageIds, settingsEntityIds: contract.settingsEntityIds, pageIds, resourceIds },
+    content: invocation.content,
+    onProgress,
+  });
+  problems.push(...checked.problems);
+  reportThemeWarnings(checked.presentation, onProgress);
 
-  const forms = await validateFixtureForms(fixtureRoot, manifest.forms, onProgress);
+  const manifestByFile = new Map(manifest.pages.map((entry) => [entry.file, entry]));
+  const validatedPages = [];
+  for (const page of checked.pages?.planned ?? []) {
+    // A source the manifest does not bind is already reported as untracked.
+    if (!manifestByFile.has(page.file)) continue;
+    const bound = await collectProblems(problems, { area: CHECK_AREA.pages, file: page.file }, () => {
+      requireFixturePageBound(page, manifestByFile.get(page.file), { imageIds, videoIds, deliveryOrigins });
+      return true;
+    });
+    if (bound) validatedPages.push({ file: page.file, path: page.pagePath });
+  }
+  await collectProblems(problems, { area: "fixture", file: FIXTURE_MANIFEST_FILE_NAME }, () => {
+    requireFixtureRecordsMatch(manifest, checked);
+    // A forms folder that failed to read is already its own problem.
+    if (checked.forms !== undefined) requireFixtureFormsBound(manifest.forms, checked.forms);
+  });
+  refuseProblems(problems, "validate found problems in the fixture");
 
-  const reportedPages = boundedList(validatedPages, MAXIMUM_REPORTED);
+  const hints = pageHints(checked, onProgress);
   onProgress(
-    `Validated ${validatedPages.length} page(s), ${navigation.items} navigation item(s), two themes, appearance, and footer without credentials or mutation.`,
+    `Validated ${validatedPages.length} page(s), ${checked.navigation.items} navigation item(s), two themes, appearance, and footer without credentials or mutation.`,
   );
   return successResult(VERB_VALIDATE, manifest.siteId, {
     offline: true,
@@ -699,27 +713,7 @@ export async function validateFixture(invocation = {}) {
       videoIds: videoIds.size,
       deliveryOrigins: deliveryOrigins.size,
     },
-    validated: {
-      pages: {
-        total: validatedPages.length,
-        items: reportedPages.items,
-        ...(reportedPages.truncated ? { itemsTruncated: true } : {}),
-      },
-      navigation: { items: navigation.items, maximumDepth: NAVIGATION_MAXIMUM_DEPTH },
-      redirects: {
-        entries: redirects.entries.length,
-        gone: redirects.entries.filter((entry) => entry.kind === REDIRECT_KIND_GONE).length,
-      },
-      ...(forms === undefined ? {} : { forms: { count: forms.length } }),
-      themes: 2,
-      appearanceSettings: presentation.scalarOperations.length,
-      footer: true,
-    },
-    warnings: {
-      items: presentation.themes.warnings,
-      count: presentation.themes.warningCount,
-      ...(presentation.themes.warningsTruncated ? { truncated: true } : {}),
-    },
+    ...validatedSummary(checked, validatedPages),
     hints,
     proves: [
       "fixture structure and bounded files",
@@ -739,3 +733,56 @@ export async function validateFixture(invocation = {}) {
     nextStep: "Run a real pull and authorized preview before approval or deployment.",
   });
 }
+
+/**
+ * `validate` over a workspace `pull` wrote (TR01002). The same checks a push
+ * runs before it sends anything, for every page and setting at once, against
+ * what the manifests recorded at the pull — no credential and no request.
+ */
+async function validatePulledWorkspace(workspaceDir, siteId, invocation, onProgress) {
+  onProgress(`Reading ${MANIFEST_FILE_NAME}.`);
+  const manifest = await readManifest(workspaceDir, siteId);
+  const mediaManifest = await readMediaManifest(workspaceDir, siteId);
+  const checked = await checkWorkspace({
+    workspaceDir,
+    siteId,
+    manifest,
+    mediaManifest,
+    content: invocation.content,
+    onProgress,
+  });
+  reportThemeWarnings(checked.presentation, onProgress);
+  refuseProblems(checked.problems, "validate found problems in the workspace");
+
+  const pages = checked.settingsOnly
+    ? []
+    : checked.pages.planned.map((page) => ({ file: page.file, path: page.pagePath }));
+  const hints = pageHints(checked, onProgress);
+  onProgress(
+    checked.settingsOnly
+      ? "Validated the workspace's two themes, appearance, and footer without credentials or mutation."
+      : `Validated ${pages.length} page(s), ${checked.navigation.items} navigation item(s), two themes, appearance, and `
+        + "footer without credentials or mutation.",
+  );
+  return successResult(VERB_VALIDATE, siteId, {
+    offline: true,
+    workspace: { manifest: MANIFEST_FILE_NAME, settingsOnly: checked.settingsOnly },
+    ...validatedSummary(checked, pages),
+    hints,
+    proves: [
+      "every page source: metadata, Markdown conversion, media references, content vocabulary, and section contexts",
+      "page paths, templates, and system pages against the pages the pull recorded",
+      "navigation shape and page references the pull recorded",
+      "redirect-map shape, normalization, chains, loops, and workspace page paths",
+      "complete theme, appearance, header, brand, and footer semantics",
+      "form files against the shared field schema",
+    ],
+    doesNotProve: [
+      "credential authorization or live site ownership",
+      "pages, revisions, or videos that changed on the site since the pull",
+      "server normalization and pull round trips",
+      "preview or published rendering",
+    ],
+    nextStep: "Run 'taproot-site plan' to check the workspace against the live site and see the ordered apply.",
+  });
+}

package/src/video-prepare.js

@@ -62,19 +62,10 @@ export async function prepareVideoFile({ filePath, byteLength, maxRemuxBytes = D
   const input = new Input({ source: new FilePathSource(filePath), formats: ALL_FORMATS });
   try {
     const format = await input.getFormat();
-    const video = await input.getPrimaryVideoTrack();
-    const audio = await input.getPrimaryAudioTrack();
-    // The server refuses a file if any track is not H.264 or AAC, so the first track that is
-    // not is the one declared and named. A track whose codec mediabunny cannot name is
-    // "unknown", not absent: an absent audio track is fine, a silent copy of one that exists is not.
-    const videoCodec = await declaredCodec(await input.getVideoTracks(), isH264);
-    const audioCodec = await declaredCodec(await input.getAudioTracks(), isAac);
+    const tracks = await inspectTracks(input);
+    const { video, audio, videoCodec, audioCodec, primaryVideo, primaryAudio } = tracks;
     const described = { videoCodec, audioCodec, remuxed: null };
-
-    // A remux keeps only the primary tracks, so they are what must be accepted for it to help.
-    const primaryVideo = video ? await codecOf(video) : "";
-    const primaryAudio = audio ? await codecOf(audio) : "";
-    if (!isH264(primaryVideo) || !isAac(primaryAudio)) return described;
+    if (!primariesAccepted(tracks)) return described;
 
     const everyTrackAccepted = isH264(videoCodec) && isAac(audioCodec);
     if (everyTrackAccepted && format.mimeType === "video/mp4" && await indexComesFirst(filePath)) return described;
@@ -97,6 +88,51 @@ export async function prepareVideoFile({ filePath, byteLength, maxRemuxBytes = D
   }
 }
 
+/**
+ * Whether the upload would send this file in a form the server accepts (TR00823): H.264
+ * and AAC as it is, or primaries a remux can keep within the ceiling. Read only; `plan`
+ * uses it so an unsupported video blocks before anything is uploaded. A remux that fails
+ * at upload time is still refused then.
+ */
+export async function videoAcceptance({ filePath, byteLength, maxRemuxBytes = DEFAULT_MAX_REMUX_BYTES }) {
+  const input = new Input({ source: new FilePathSource(filePath), formats: ALL_FORMATS });
+  try {
+    const tracks = await inspectTracks(input);
+    const { videoCodec, audioCodec } = tracks;
+    const asItIs = isH264(videoCodec) && isAac(audioCodec);
+    const remuxable = primariesAccepted(tracks) && byteLength <= maxRemuxBytes;
+    return { accepted: asItIs || remuxable, videoCodec, audioCodec };
+  } catch {
+    return { accepted: false, videoCodec: "", audioCodec: "" };
+  } finally {
+    input.dispose();
+  }
+}
+
+/**
+ * The server refuses a file if any track is not H.264 or AAC, so the first track that is
+ * not is the one declared and named. A track whose codec mediabunny cannot name is
+ * "unknown", not absent: an absent audio track is fine, a silent copy of one that exists is
+ * not. A remux keeps only the primary tracks, so they are what must be accepted for it to help.
+ */
+async function inspectTracks(input) {
+  const video = await input.getPrimaryVideoTrack();
+  const audio = await input.getPrimaryAudioTrack();
+  return {
+    video,
+    audio,
+    videoCodec: await declaredCodec(await input.getVideoTracks(), isH264),
+    audioCodec: await declaredCodec(await input.getAudioTracks(), isAac),
+    primaryVideo: video ? await codecOf(video) : "",
+    primaryAudio: audio ? await codecOf(audio) : "",
+  };
+}
+
+/** Whether a remux, which keeps only the primary tracks, would produce a file the server accepts. */
+function primariesAccepted({ primaryVideo, primaryAudio }) {
+  return isH264(primaryVideo) && isAac(primaryAudio);
+}
+
 async function codecOf(track) {
   return (await track.getCodecParameterString()) ?? "unknown";
 }