app/lib/operator/sync-tools.server.ts

Functions

Imports

It imports app/db/cv.ts, app/db/index.ts, app/db/phages.ts, app/db/schema.ts, app/kb/procedures/parse.mjs, app/kb/procedures/primer-dependents.server.ts, app/kb/procedures/save.server.ts, app/kb/registry/compile.mjs, app/kb/registry/save.server.ts, app/lib/cache-purge.server.ts, app/lib/cv/parse.mjs, app/lib/cv/pdf-html.mjs, app/lib/cv/pdf.server.ts, app/lib/cv/save.server.ts, app/lib/dictionary/parse.mjs, app/lib/dictionary/save.server.ts, app/lib/editor/divergence.server.ts, app/lib/editor/github.server.ts, app/lib/editor/post-rows.server.ts, app/lib/editor/publish.server.ts, app/lib/health/checks.server.ts, app/lib/health/verdicts.mjs, app/lib/llms/save.server.ts, app/lib/media/backup.server.ts, app/lib/media/rebuild.server.ts, app/lib/operator/auth.server.ts, app/lib/operator/descriptors.ts, app/lib/operator/sync-report.mjs, app/lib/pages/compile.mjs, app/lib/pages/save.server.ts, app/lib/phages/compile.mjs, app/lib/phages/save.server.ts, app/lib/publications/parse.mjs, app/lib/publications/save.server.ts, app/lib/roster/compile.mjs, app/lib/roster/save.server.ts, app/lib/search/ask.server.ts. Imported by app/lib/operator/api.server.ts.

Source

1// The convergence tools: each re-derives one store from its source and reports a read-back verdict,
2// plus the cockpit's per-store counts.
3
4import { count } from "drizzle-orm";
5
6import { getDb, publiclyVisible } from "~/db";
7import { posts as postsTable } from "~/db/schema";
8import { listDivergences } from "~/lib/editor/divergence.server";
9import { EditorError, currentHead, renderAndWrite } from "~/lib/editor/publish.server";
10import { deletePostFromD1 } from "~/lib/editor/post-rows.server";
11import { listPostFiles, readFile } from "~/lib/editor/github.server";
12import { askAvailable, askIndexStatus, pruneAskCorpus, syncAskCorpus } from "~/lib/search/ask.server";
13import { mediaIndexStatus, rebuildMediaIndex } from "~/lib/media/rebuild.server";
14import { copyMissingTwins } from "~/lib/media/backup.server";
15import {
16  readContentSides,
17  readLlmsSides,
18  readCvSides,
19  readDictionarySides,
20  readPageSides,
21  readProcedureSides,
22  readPublicationSides,
23  readPhageSides,
24  readRegistrySides,
25  readRosterSides,
26} from "~/lib/health/checks.server";
27import { purgeCv, purgeLlms, purgePages, purgePhages, purgeProcedures, purgePublications, purgeRegistry, purgeRoster } from "~/lib/cache-purge.server";
28import { compileLlms, writeLlmsRow } from "~/lib/llms/save.server";
29import { readCv } from "~/db/cv";
30import { CV_DIR } from "~/lib/cv/parse.mjs";
31import { cvFingerprint } from "~/lib/cv/pdf-html.mjs";
32import { ensureCvPdf, storedCvPdfFingerprint } from "~/lib/cv/pdf.server";
33import { compile as compileCvFile, deleteCvRow, refreshCvSearch, writeCvRow } from "~/lib/cv/save.server";
34import { DICTIONARY_DIR } from "~/lib/dictionary/parse.mjs";
35import {
36  compile as compileDictionaryFile,
37  deleteRow as deleteDictionaryRow,
38  writeRow as writeDictionaryRow,
39} from "~/lib/dictionary/save.server";
40import { PAGES_DIR } from "~/lib/pages/compile.mjs";
41import {
42  compile as compilePageFile,
43  deletePageRow,
44  writeRow as writePageRow,
45} from "~/lib/pages/save.server";
46import { PUBLICATIONS_DIR } from "~/lib/publications/parse.mjs";
47import { listPhages } from "~/db/phages";
48import { PHAGES_DIR, phageSlug, type Phage } from "~/lib/phages/compile.mjs";
49import { compile as compilePhageFile, deletePhageRow, refreshPage as refreshPhagePage, writePhageRow } from "~/lib/phages/save.server";
50import { REGISTRY_DIR } from "~/kb/registry/compile.mjs";
51import { refreshProceduresNaming } from "~/kb/procedures/primer-dependents.server";
52import { compile as compileRegistryFile, deleteRegistryRow, writeRegistryRow } from "~/kb/registry/save.server";
53import { ROSTER_DIR } from "~/lib/roster/compile.mjs";
54import { compile as compileRosterFile, deleteRosterRow, writeRosterRow } from "~/lib/roster/save.server";
55import {
56  compilePublicationFor,
57  deletePublicationRow,
58  seedMissingCitations,
59  writePublicationRow,
60} from "~/lib/publications/save.server";
61import { PROCEDURES_DIR } from "~/kb/procedures/parse.mjs";
62import {
63  compile as compileProcedureFile,
64  deleteProcedureRow,
65  writeRow as writeProcedureRow,
66} from "~/kb/procedures/save.server";
67import { contentDriftCompare } from "~/lib/health/verdicts.mjs";
68
69import type { OperatorEnv } from "./auth.server";
70import type { ToolResult } from "./descriptors";
71import { askSyncReport, mediaSyncReport } from "./sync-report.mjs";
72
73// Posts published by COMMIT never pass through `savePost`, so this keeps Ask in step for them.
74export async function syncAsk(env: OperatorEnv): Promise<ToolResult> {
75  if (!askAvailable(env)) {
76    // An absent binding means the feature is not here, rather than here and broken.
77    return { ok: false, status: 404, error: "Ask is not enabled on this deployment." };
78  }
79
80  const { uploaded, keys, failed, cacheDropped } = await syncAskCorpus(env);
81  const removed = await pruneAskCorpus(env, keys);
82
83  // The index is eventually consistent, so drift here may be a moment behind. A key in `failed` was
84  // never written, and the report refuses convergence on it.
85  const status = await askIndexStatus(env);
86
87  return {
88    ok: true,
89    data: askSyncReport({
90      uploaded,
91      removed: removed.length,
92      cacheDropped,
93      expected: status.expected,
94      present: status.present,
95      failed,
96    }),
97  };
98}
99
100// Safe unattended: no delete branch in either bucket, and it never writes the primary.
101export async function backupMedia(env: OperatorEnv): Promise<ToolResult> {
102  const { copied, gone, status } = await copyMissingTwins(env);
103
104  return {
105    ok: true,
106    data: {
107      copied,
108      // Vanished between the comparison and the copy: not an error, the twin is what the mirror is for.
109      gone,
110      objects: status.objects,
111      twins: status.twins,
112      missing: status.missing.length,
113      mismatched: status.mismatched.length,
114      converged: status.missing.length === 0 && status.mismatched.length === 0,
115    },
116  };
117}
118
119export async function syncMedia(env: OperatorEnv): Promise<ToolResult> {
120  const rebuilt = await rebuildMediaIndex(env);
121  const status = await mediaIndexStatus(env);
122
123  return {
124    ok: true,
125    data: mediaSyncReport({
126      indexed: rebuilt.indexed,
127      removed: rebuilt.removed,
128      failures: rebuilt.failures,
129      expected: status.expected,
130      present: status.present,
131      missing: status.missing,
132      extra: status.extra,
133    }),
134  };
135}
136
137// Derives its work from the same comparison the health check uses, and every drifted slug goes through
138// the one render door. An empty listing is refused as convergeKind refuses it: content/posts answering
139// with no markdown is a fault, and honouring it would delete every post row (Grok audit 2026-10-21, DE-1).
140export async function syncPosts(env: OperatorEnv): Promise<ToolResult> {
141  const before = await readContentSides(env);
142  if (before.files.length === 0) {
143    return {
144      ok: false,
145      status: 422,
146      error:
147        "sync_posts refused: content/posts lists no post files, and converging to an empty set " +
148        "would delete every post row. Check the repository listing.",
149    };
150  }
151  const drift = contentDriftCompare(before.files, before.rows);
152
153  const fileBySlug = new Map(before.files.map((f) => [f.slug, f]));
154  let repaired = 0;
155  // A failed purge never fails the repair, but it is counted: those pages stay stale until expiry.
156  let unpurged = 0;
157  for (const slug of [...drift.changed, ...drift.unrowed]) {
158    const entry = fileBySlug.get(slug);
159    if (!entry) continue;
160    const file = await readFile(env, entry.path);
161    if (!file) {
162      throw new EditorError(
163        `"${entry.path}" vanished between the listing and the read; main moved ` +
164          `mid-repair. Re-run sync_posts.`,
165      );
166    }
167    if ((await renderAndWrite(env, slug, file.content, entry.sha)).purged === false) unpurged += 1;
168    repaired += 1;
169  }
170
171  let removed = 0;
172  for (const slug of drift.unfiled) {
173    if ((await deletePostFromD1(env, slug)).purged === false) unpurged += 1;
174    removed += 1;
175  }
176
177  return convergedResult(await readContentSides(env), { repaired, removed, unpurged });
178}
179
180/** A converge's answer, read after its writes: D1 reads its own writes in-request, so drift reported here is real. */
181function convergedResult(
182  after: { files: Array<{ slug: string; sha: string }>; rows: Array<{ slug: string; source_blob_sha: string | null }> },
183  counts: { repaired: number; removed: number; unpurged: number },
184): ToolResult {
185  const residual = contentDriftCompare(after.files, after.rows);
186  const residualCount = residual.changed.length + residual.unrowed.length + residual.unfiled.length;
187  return {
188    ok: true,
189    data: {
190      ...counts,
191      expected: after.files.length,
192      present: after.files.length - residual.changed.length - residual.unrowed.length,
193      converged: residualCount === 0,
194    },
195  };
196}
197
198type DriftSides<Row extends { slug: string; source_blob_sha: string | null }> = {
199  files: Array<{ slug: string; sha: string; path: string }>;
200  rows: Row[];
201};
202
203/**
204 * What differs between the kinds that converge from files to D1 rows (procedures, pages, publications):
205 * the two sides, the compile door and the write and removal doors the kind's own save uses. The loop is one.
206 */
207type CompileResult = { ok: boolean; errors: string[] };
208type CompiledOk<Result extends CompileResult> = Extract<Result, { ok: true }> & { sourceBlobSha: string };
209
210type KindSync<Row extends { slug: string; source_blob_sha: string | null }, Result extends CompileResult> = {
211  tool: string;
212  dir: string;
213  noun: string;
214  read: () => Promise<DriftSides<Row>>;
215  compile: (slug: string, raw: string) => Promise<Result>;
216  write: (compiled: CompiledOk<Result>) => Promise<void>;
217  remove: (row: Row) => Promise<void>;
218  purge: (why: string) => Promise<boolean | null>;
219  /**
220   * For a kind whose rows feed another derived store (the phages draw a page): runs once, after the comparison and
221   * before any row moves, so that store settles to the final set first and a failure leaves the rows reading
222   * drifted, to be retried. Throws to stop the repair.
223   */
224  settle?: (plan: { files: DriftSides<Row>["files"]; rows: Row[]; drift: ReturnType<typeof contentDriftCompare> }) => Promise<void>;
225  /**
226   * For a kind that legitimately has no files yet (the registry, before any kind brings records): no files AND no
227   * rows is a converged nothing, not a fault. No files while rows exist is still refused, because that is the
228   * listing that came back empty and would delete every row.
229   */
230  emptyOk?: boolean;
231};
232
233/**
234 * Converges one kind's table to its files through the compile and write doors its save uses, from the same
235 * comparison its health check runs. Idempotent. An empty file set is refused, as scripts/sync-content.mjs
236 * refuses it: a listing that came back empty is far likelier a fault than a repository with none, and
237 * honouring it would delete every row.
238 *
239 * A file that fails the validator cannot be written: every other drifted file is still converged, then the
240 * failures are returned as a 422 naming each file and its messages, so the repair never reports success
241 * over a file it could not apply.
242 */
243async function convergeKind<
244  Row extends { slug: string; source_blob_sha: string | null },
245  Result extends CompileResult,
246>(env: OperatorEnv, spec: KindSync<Row, Result>): Promise<ToolResult> {
247  const before = await spec.read();
248  if (before.files.length === 0 && before.rows.length === 0 && spec.emptyOk) {
249    return { ok: true, data: { repaired: 0, removed: 0, unpurged: 0, expected: 0, present: 0, converged: true } };
250  }
251  if (before.files.length === 0) {
252    return {
253      ok: false,
254      status: 422,
255      error:
256        `${spec.tool} refused: ${spec.dir} lists no ${spec.noun} files, and converging to an empty set ` +
257        `would delete every ${spec.noun} row. Check the repository listing.`,
258    };
259  }
260  const drift = contentDriftCompare(before.files, before.rows);
261  if (spec.settle && drift.changed.length + drift.unrowed.length + drift.unfiled.length > 0) {
262    await spec.settle({ files: before.files, rows: before.rows, drift });
263  }
264
265  const fileBySlug = new Map(before.files.map((f) => [f.slug, f]));
266  let repaired = 0;
267  const failed: Array<{ slug: string; path: string; errors: string[] }> = [];
268  for (const slug of [...drift.changed, ...drift.unrowed]) {
269    const entry = fileBySlug.get(slug);
270    if (!entry) continue;
271    const file = await readFile(env, entry.path);
272    if (!file) {
273      throw new EditorError(
274        `"${entry.path}" vanished between the listing and the read; main moved mid-repair. Re-run ${spec.tool}.`,
275      );
276    }
277    const compiled = await spec.compile(slug, file.content);
278    if (!compiled.ok) {
279      failed.push({ slug, path: entry.path, errors: compiled.errors });
280      continue;
281    }
282    const done = compiled as CompiledOk<Result>;
283    // Compiled from the bytes read, which must be the bytes listed, or the row would claim a sha it is not.
284    if (done.sourceBlobSha !== entry.sha) {
285      throw new EditorError(
286        `"${entry.path}" changed between the listing and the read; main moved mid-repair. Re-run ${spec.tool}.`,
287      );
288    }
289    await spec.write(done);
290    repaired += 1;
291  }
292
293  const rowBySlug = new Map(before.rows.map((r) => [r.slug, r]));
294  let removed = 0;
295  for (const slug of drift.unfiled) {
296    const row = rowBySlug.get(slug);
297    if (!row) continue;
298    await spec.remove(row);
299    removed += 1;
300  }
301
302  // A failed purge never fails the repair, but it is counted: those pages stay stale until expiry.
303  let unpurged = 0;
304  if (repaired + removed > 0 && (await spec.purge(spec.tool)) === false) unpurged = 1;
305
306  if (failed.length > 0) {
307    return {
308      ok: false,
309      status: 422,
310      error:
311        `${spec.tool} could not apply ${failed.length} file(s): ` +
312        failed.map((f) => `${f.path} fails ${f.errors.length} check(s), first: ${f.errors[0]}`).join("; ") +
313        `. The other ${repaired} drifted ${spec.noun}(s) were converged.`,
314      detail: { failed, repaired, removed },
315    };
316  }
317
318  return convergedResult(await spec.read(), { repaired, removed, unpurged });
319}
320
321/** Procedures: the compile and write doors save_procedure uses. */
322export async function syncProcedures(env: OperatorEnv): Promise<ToolResult> {
323  return convergeKind(env, {
324    tool: "sync_procedures",
325    dir: PROCEDURES_DIR,
326    noun: "procedure",
327    read: () => readProcedureSides(env),
328    compile: (slug, raw) => compileProcedureFile(env, slug, raw),
329    write: (compiled) => writeProcedureRow(env, compiled),
330    remove: (row) => deleteProcedureRow(env, row),
331    purge: purgeProcedures,
332  });
333}
334
335/**
336 * Dictionary entries: the compile and write doors a dictionary save uses, which also re-derive the one page
337 * row each entry opens (its twin and its search records), and purge the pages tag, because the page embeds the
338 * entry. An entry whose path is not a registered Software page, or whose clip is not in the repository, is
339 * refused by the compile (the 422 names the file) and never makes a row.
340 */
341export async function syncDictionary(env: OperatorEnv): Promise<ToolResult> {
342  return convergeKind(env, {
343    tool: "sync_dictionary",
344    dir: DICTIONARY_DIR,
345    noun: "dictionary entry",
346    read: () => readDictionarySides(env),
347    compile: (key, raw) => compileDictionaryFile(env, key, raw),
348    write: (compiled) => writeDictionaryRow(env, compiled),
349    remove: (row) => deleteDictionaryRow(env, { key: row.slug, path: row.path }),
350    purge: purgePages,
351  });
352}
353
354/**
355 * Pages: the compile and write doors a page save uses. A file whose path is not in CONTENT_PAGE_PATHS (or About's, CONTENT_PAGES_OWN_ROUTE) is
356 * refused by the compile (the 422 names the file) and never makes a row.
357 */
358export async function syncPages(env: OperatorEnv): Promise<ToolResult> {
359  return convergeKind(env, {
360    tool: "sync_pages",
361    dir: PAGES_DIR,
362    noun: "page",
363    read: () => readPageSides(env),
364    compile: (slug, raw) => compilePageFile(env, slug, raw),
365    write: (compiled) => writePageRow(env, compiled),
366    remove: (row) => deletePageRow(env, row),
367    purge: purgePages,
368  });
369}
370
371/**
372 * The CV: the compile and write doors a CV save uses, one row per file. The CV's search records depend on every
373 * file, so they are rewritten once after the rows, in the step that also purges the CV's cache tag. A failure
374 * there is thrown, not counted: a repair that left the search records behind must not report success.
375 */
376export async function syncCv(env: OperatorEnv): Promise<ToolResult> {
377  return convergeKind(env, {
378    tool: "sync_cv",
379    dir: CV_DIR,
380    noun: "CV file",
381    read: () => readCvSides(env),
382    compile: (slug, raw) => compileCvFile(env, slug, raw),
383    write: (compiled) => writeCvRow(env, compiled),
384    remove: (row) => deleteCvRow(env, row),
385    purge: async (why) => {
386      await refreshCvSearch(env);
387      return purgeCv(why);
388    },
389  });
390}
391
392/**
393 * Publications: the compile and write doors a publication save uses. Each written row is read back for
394 * its twin's bytes, because the twin goes in as chunks and this is what proves they joined. A citation
395 * count that exists is never touched; one that is missing is seeded from the committed snapshot.
396 */
397export async function syncPublications(env: OperatorEnv): Promise<ToolResult> {
398  return convergeKind(env, {
399    tool: "sync_publications",
400    dir: PUBLICATIONS_DIR,
401    noun: "publication",
402    read: () => readPublicationSides(env),
403    compile: (slug, raw) => compilePublicationFor(env, slug, raw),
404    write: async (compiled) => {
405      await writePublicationRow(env, compiled);
406      const stored = await env.DB.prepare(
407        "SELECT source_blob_sha, length(CAST(markdown AS BLOB)) AS twin_bytes FROM publications WHERE slug = ?1",
408      )
409        .bind(compiled.record.slug)
410        .first<{ source_blob_sha: string; twin_bytes: number }>();
411      const twinBytes = new TextEncoder().encode(compiled.twin).length;
412      if (stored?.source_blob_sha !== compiled.sourceBlobSha || stored.twin_bytes !== twinBytes) {
413        throw new Error(
414          `sync_publications wrote "${compiled.record.slug}" but the row read back does not match its file ` +
415            `(twin ${stored?.twin_bytes ?? "missing"} bytes, expected ${twinBytes}). Re-run sync_publications.`,
416        );
417      }
418      await seedMissingCitations(env, [compiled.record.doi]);
419    },
420    remove: (row) => deletePublicationRow(env, row),
421    purge: purgePublications,
422  });
423}
424
425/**
426 * llms.txt: the compile and write doors an llms.txt save uses, through the same loop as the kinds above,
427 * with one file and one settings row. The write reads the row back. A repository with no llms.txt is
428 * refused as an empty set; the row is never deleted.
429 */
430export async function syncLlms(env: OperatorEnv): Promise<ToolResult> {
431  return convergeKind(env, {
432    tool: "sync_llms",
433    dir: "content",
434    noun: "llms.txt",
435    read: () => readLlmsSides(env),
436    compile: (_slug, raw) => compileLlms(env, raw),
437    write: (compiled) => writeLlmsRow(env, compiled.raw),
438    remove: async () => {
439      throw new Error("sync_llms never removes the llms.txt row: a repository without the file is refused first.");
440    },
441    purge: purgeLlms,
442  });
443}
444
445/**
446 * The CV's PDF: renders it from the CV D1 holds now and replaces the one stored object, unless the stored object
447 * already carries that CV's fingerprint (then it renders nothing). The same door a CV save's background render
448 * uses (ensureCvPdf), then read back: `converged` is the stored fingerprint equalling the data's, derived here and
449 * never asserted. A failed render is thrown, so the repair reports failure instead of success, and nothing
450 * stored is changed by it.
451 */
452export async function syncCvPdf(env: OperatorEnv): Promise<ToolResult> {
453  const outcome = await ensureCvPdf(env);
454  const [stored, cv] = await Promise.all([storedCvPdfFingerprint(env), readCv(env)]);
455  const present = stored === (await cvFingerprint(cv)) ? 1 : 0;
456  return {
457    ok: true,
458    data: {
459      action: outcome.action,
460      fingerprint: outcome.fingerprint,
461      ...(outcome.action === "stored" ? { bytes: outcome.bytes, purged: outcome.purged } : {}),
462      expected: 1,
463      present,
464      drift: 1 - present,
465      converged: present === 1,
466    },
467  };
468}
469
470/**
471 * The roster: the compile and write doors a roster save uses. A cohort is one row, written whole, and the purge
472 * reaches both pages that embed it (purgeRoster).
473 */
474export async function syncRoster(env: OperatorEnv): Promise<ToolResult> {
475  return convergeKind(env, {
476    tool: "sync_roster",
477    dir: ROSTER_DIR,
478    noun: "cohort",
479    read: () => readRosterSides(env),
480    compile: (slug, raw) => compileRosterFile(env, slug, raw),
481    write: (compiled) => writeRosterRow(env, compiled),
482    remove: (row) => deleteRosterRow(env, row),
483    purge: purgeRoster,
484  });
485}
486
487/**
488 * The phage table: the compile and write doors a phage save uses. The page /research/phages is compiled from the
489 * rows, so before any row moves the page row is re-derived ONCE from the final set (this repository's files
490 * where they compile, D1's row where one does not, minus the phages whose file is gone), and each phage row is
491 * written after it. A failure of that refresh stops the repair with every phage still reading drifted, so the
492 * next run retries it. The purge reaches the one page that embeds the table (purgePhages).
493 */
494export async function syncPhages(env: OperatorEnv): Promise<ToolResult> {
495  return convergeKind(env, {
496    tool: "sync_phages",
497    dir: PHAGES_DIR,
498    noun: "phage",
499    read: () => readPhageSides(env),
500    compile: (slug, raw) => compilePhageFile(env, slug, raw),
501    write: (compiled) => writePhageRow(env, compiled),
502    remove: (row) => deletePhageRow(env, row),
503    purge: purgePhages,
504    settle: async ({ files, drift }) => {
505      const bySlug = new Map<string, Phage>((await listPhages(env)).map((phage) => [phageSlug(phage.name), phage]));
506      const pathOf = new Map(files.map((f) => [f.slug, f.path]));
507      for (const slug of [...drift.changed, ...drift.unrowed]) {
508        const path = pathOf.get(slug);
509        const file = path ? await readFile(env, path) : null;
510        if (!file) continue;
511        // A file that does not compile keeps whatever D1 holds for it; convergeKind then reports it as a 422.
512        const compiled = await compilePhageFile(env, slug, file.content);
513        if (compiled.ok) bySlug.set(slug, compiled.phage);
514      }
515      for (const slug of drift.unfiled) bySlug.delete(slug);
516      await refreshPhagePage(env, [...bySlug.values()]);
517    },
518  });
519}
520
521/**
522 * The registry: the compile and write doors a registry save uses. Nothing else is derived from a registry row, so
523 * there is no settle step, and the purge is the registry's tag. It has no files until a kind brings records, so an
524 * empty set with no rows is converged (emptyOk); an empty set with rows is refused like every other kind's.
525 */
526export async function syncRegistry(env: OperatorEnv): Promise<ToolResult> {
527  const result = await convergeKind(env, {
528    tool: "sync_registry",
529    dir: REGISTRY_DIR,
530    noun: "registry item",
531    read: () => readRegistrySides(env),
532    compile: (slug, raw) => compileRegistryFile(env, slug, raw),
533    write: (compiled) => writeRegistryRow(env, compiled),
534    remove: (row) => deleteRegistryRow(env, row),
535    purge: purgeRegistry,
536    emptyOk: true,
537  });
538  // The protocols that print a primer carry its facts in their record, so every one that names a primer is recompiled
539  // from its file after the primers converge: a primer edited through git reaches them here, and a protocol left reading
540  // an old sequence by a failed save is repaired by the same run.
541  const refreshed = await refreshProceduresNaming(env, null, ["primer", "strain", "reagent", "equipment"]);
542  return result.ok ? { ok: true, data: { ...(result.data as object), protocolsRefreshed: refreshed.length } } : result;
543}
544
545// Stores reported SEPARATELY: they fail independently. Exported because the cockpit renders this rather
546// than computing a second answer.
547export async function syncStatus(env: OperatorEnv) {
548  // Counted through Drizzle: interpolating the predicate into a template string stringifies the object and
549  // D1 answers `no such column`. `publiclyVisible()` is reused so the visibility rule has one owner.
550  const db = getDb(env);
551  // The stores are separate and each read is independent (GitHub twice, D1 three times, KV once), so they run
552  // together: the status takes as long as the slowest read, not the sum of all of them.
553  const [repoFiles, totalRow, visibleRow, indexed, headSha, divergences] = await Promise.all([
554    listPostFiles(env),
555    db.select({ n: count() }).from(postsTable).get(),
556    db.select({ n: count() }).from(postsTable).where(publiclyVisible()).get(),
557    env.DB.prepare("SELECT COUNT(*) AS n FROM search_identity_docsize").first<{ n: number }>(),
558    currentHead(env),
559    listDivergences(env),
560  ]);
561  const repoPosts = repoFiles.length;
562
563  // A COUNT always returns one row; a missing one is an unreadable answer, never zero posts.
564  const counted = (row: { n: number } | null | undefined, what: string) => {
565    if (typeof row?.n !== "number") throw new Error(`syncStatus: the ${what} count returned no row`);
566    return row.n;
567  };
568
569  return {
570    headSha,
571    artifactPosts: repoPosts,
572    d1Posts: counted(totalRow, "posts"),
573    d1PubliclyVisible: counted(visibleRow, "publicly visible posts"),
574    // The docsize shadow table: `COUNT(*)` on the index reads through to the content table and never drifts.
575    searchIndexDocs: counted(indexed, "search index"),
576    askConfigured: askAvailable(env),
577    githubConfigured: Boolean(env.GITHUB_TOKEN),
578    // Read from KV: a record of a D1 failure kept in D1 is missing exactly when it matters. `known: false`
579    // is not the same answer as an empty list.
580    divergences,
581  };
582}