@fitlab-ai/agent-infra 0.9.14 → 0.10.0

package/lib/task/manual-validation-completion.ts

@@ -0,0 +1,40 @@
+import { readManualValidationReceipt } from './manual-validation-receipt.ts';
+import type { ManualValidationReceipt, ManualValidationReceiptError, ManualValidationReceiptIdentity } from './manual-validation-receipt.ts';
+import { readManualValidationTransaction } from './manual-validation-transaction.ts';
+import type { ManualValidationTransaction, ManualValidationTransactionError } from './manual-validation-transaction.ts';
+
+type ManualValidationCompletionIdentity = ManualValidationReceiptIdentity & Readonly<{
+  receiptDigest?: string;
+}>;
+type ManualValidationCompletion = Readonly<{
+  receipt: ManualValidationReceipt;
+  transaction: ManualValidationTransaction;
+}>;
+type ManualValidationCompletionError = ManualValidationReceiptError | ManualValidationTransactionError;
+type ManualValidationCompletionResult =
+  | { ok: true; value: ManualValidationCompletion }
+  | { ok: false; error: ManualValidationCompletionError };
+
+function readManualValidationCompletion(taskDir: string, expected: ManualValidationCompletionIdentity = {}): ManualValidationCompletionResult {
+  const { receiptDigest: expectedReceiptDigest, ...receiptIdentity } = expected;
+  const receipt = readManualValidationReceipt(taskDir, receiptIdentity);
+  if (!receipt.ok) return receipt;
+  if (expectedReceiptDigest !== undefined && receipt.value.receiptDigest !== expectedReceiptDigest) {
+    return { ok: false, error: { code: 'MANUAL_VALIDATION_RECEIPT_IDENTITY_MISMATCH', message: 'receipt digest does not match the expected completion' } };
+  }
+  const transaction = readManualValidationTransaction(taskDir, {
+    transactionId: receipt.value.transactionId,
+    taskId: receipt.value.taskId,
+    prNumber: receipt.value.prNumber,
+    prHeadSha: receipt.value.prHeadSha,
+    artifact: receipt.value.artifact
+  });
+  if (!transaction.ok) return transaction;
+  if (transaction.value.committedReceipt !== receipt.value.receiptDigest) {
+    return { ok: false, error: { code: 'MANUAL_VALIDATION_TRANSACTION_PHASE_INVALID', message: 'completion transaction is not bound to the canonical receipt' } };
+  }
+  return { ok: true, value: { receipt: receipt.value, transaction: transaction.value } };
+}
+
+export { readManualValidationCompletion };
+export type { ManualValidationCompletion, ManualValidationCompletionError, ManualValidationCompletionIdentity, ManualValidationCompletionResult };

package/lib/task/manual-validation-evidence.ts

@@ -0,0 +1,209 @@
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+import {
+  MANUAL_VALIDATION_SHA40 as SHA40,
+  MANUAL_VALIDATION_TASK_ID as TASK_ID,
+  exactKeys,
+  isRecord,
+  validTimestamp
+} from './manual-validation-shared.ts';
+
+const MANUAL_VALIDATION_EVIDENCE_SCHEMA = 'agent-infra/branch-only-validation-evidence';
+const MANUAL_VALIDATION_EVIDENCE_VERSION = 1;
+
+type ManualValidationMode = 'task-bound' | 'branch-only';
+type ManualValidationScope = 'snapshot' | 'inplace';
+type ManualValidationCleanup = 'completed' | 'pending' | 'failed' | 'not-created';
+type ManualValidationEvidence = Readonly<{
+  schema: typeof MANUAL_VALIDATION_EVIDENCE_SCHEMA;
+  version: typeof MANUAL_VALIDATION_EVIDENCE_VERSION;
+  mode: ManualValidationMode;
+  taskId: string | null;
+  branch: string;
+  commit: string;
+  recoverable: boolean;
+  source: 'run-manual-validation';
+  result: Readonly<{
+    scope: ManualValidationScope;
+    command: string;
+    startedAt: string;
+    completedAt: string;
+    exitCode: number;
+    signal: string | null;
+    cleanup: ManualValidationCleanup;
+  }>;
+}>;
+type ManualValidationEvidenceInput = {
+  mode: ManualValidationMode;
+  taskId: string | null;
+  branch: string;
+  commit: string;
+  recoverable: boolean;
+  scope: ManualValidationScope;
+  command: string;
+  startedAt: string;
+  completedAt: string;
+  exitCode: number;
+  signal: string | null;
+  cleanup: ManualValidationCleanup;
+};
+type ManualValidationEvidenceIdentity = {
+  taskId: string | null;
+  branch: string;
+  commit?: string;
+};
+type ManualValidationEvidenceErrorCode =
+  | 'MANUAL_VALIDATION_EVIDENCE_MISSING'
+  | 'MANUAL_VALIDATION_EVIDENCE_INVALID'
+  | 'MANUAL_VALIDATION_EVIDENCE_IDENTITY_MISMATCH'
+  | 'MANUAL_VALIDATION_EVIDENCE_UNSUCCESSFUL'
+  | 'MANUAL_VALIDATION_EVIDENCE_STALE';
+type ManualValidationEvidenceError = { code: ManualValidationEvidenceErrorCode; message: string };
+type ManualValidationEvidenceResult =
+  | { ok: true; value: ManualValidationEvidence }
+  | { ok: false; error: ManualValidationEvidenceError };
+
+function invalid(message: string): ManualValidationEvidenceResult {
+  return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_INVALID', message } };
+}
+
+function validateShape(value: unknown): ManualValidationEvidenceResult {
+  if (!isRecord(value)) return invalid('evidence must be a JSON object');
+  const topError = exactKeys(value, ['schema', 'version', 'mode', 'taskId', 'branch', 'commit', 'recoverable', 'source', 'result'], 'evidence');
+  if (topError) return invalid(topError);
+  if (value.schema !== MANUAL_VALIDATION_EVIDENCE_SCHEMA || value.version !== MANUAL_VALIDATION_EVIDENCE_VERSION) {
+    return invalid('evidence schema or version is unsupported');
+  }
+  if (value.mode !== 'task-bound' && value.mode !== 'branch-only') return invalid('mode must be task-bound or branch-only');
+  if (value.taskId !== null && (typeof value.taskId !== 'string' || !TASK_ID.test(value.taskId))) return invalid('taskId must be a TASK identifier or null');
+  if (typeof value.branch !== 'string' || !value.branch.trim() || /[\r\n]/u.test(value.branch)) return invalid('branch must be a non-empty single line');
+  if (typeof value.commit !== 'string' || !SHA40.test(value.commit)) return invalid('commit must be a 40-character lowercase hexadecimal SHA');
+  if (typeof value.recoverable !== 'boolean') return invalid('recoverable must be boolean');
+  if (value.source !== 'run-manual-validation') return invalid('source is unsupported');
+  if (value.mode === 'branch-only' && (value.taskId !== null || value.recoverable !== false)) return invalid('branch-only evidence must be non-recoverable and task-free');
+  if (value.mode === 'task-bound' && (value.taskId === null || value.recoverable !== true)) return invalid('task-bound evidence must identify a recoverable task');
+  if (!isRecord(value.result)) return invalid('result must be a JSON object');
+  const result = value.result;
+  const resultError = exactKeys(result, ['scope', 'command', 'startedAt', 'completedAt', 'exitCode', 'signal', 'cleanup'], 'result');
+  if (resultError) return invalid(resultError);
+  if (result.scope !== 'snapshot' && result.scope !== 'inplace') return invalid('result.scope is invalid');
+  if (typeof result.command !== 'string' || !result.command || /[\\/\r\n]/u.test(result.command)) return invalid('result.command must be a basename');
+  if (!validTimestamp(result.startedAt) || !validTimestamp(result.completedAt) || Date.parse(result.completedAt) < Date.parse(result.startedAt)) return invalid('result timestamps are invalid');
+  const exitCode = result.exitCode;
+  if (!Number.isSafeInteger(exitCode) || (exitCode as number) < 0) return invalid('result.exitCode must be a non-negative integer');
+  if (result.signal !== null && (typeof result.signal !== 'string' || !result.signal || /[\r\n]/u.test(result.signal))) return invalid('result.signal must be a string or null');
+  if (!['completed', 'pending', 'failed', 'not-created'].includes(result.cleanup as string)) return invalid('result.cleanup is invalid');
+  return { ok: true, value: value as unknown as ManualValidationEvidence };
+}
+
+function createManualValidationEvidence(input: ManualValidationEvidenceInput): ManualValidationEvidence {
+  const value: ManualValidationEvidence = {
+    schema: MANUAL_VALIDATION_EVIDENCE_SCHEMA,
+    version: MANUAL_VALIDATION_EVIDENCE_VERSION,
+    mode: input.mode,
+    taskId: input.taskId,
+    branch: input.branch,
+    commit: input.commit,
+    recoverable: input.recoverable,
+    source: 'run-manual-validation',
+    result: {
+      scope: input.scope,
+      command: input.command,
+      startedAt: input.startedAt,
+      completedAt: input.completedAt,
+      exitCode: input.exitCode,
+      signal: input.signal,
+      cleanup: input.cleanup
+    }
+  };
+  const checked = validateShape(value);
+  if (!checked.ok) throw new Error(`${checked.error.code}: ${checked.error.message}`);
+  return checked.value;
+}
+
+type ManualValidationEvidenceSummary = Readonly<{
+  version: 1;
+  taskId: string | null;
+  branch: string;
+  scope: ManualValidationScope;
+  commit: string;
+  command: string;
+  startedAt: string;
+  completedAt: string;
+  exitCode: number;
+  signal: string | null;
+  cleanup: ManualValidationCleanup;
+}>;
+
+function manualValidationEvidenceSummary(evidence: ManualValidationEvidence): ManualValidationEvidenceSummary {
+  return {
+    version: 1,
+    taskId: evidence.taskId,
+    branch: evidence.branch,
+    scope: evidence.result.scope,
+    commit: evidence.commit,
+    command: evidence.result.command,
+    startedAt: evidence.result.startedAt,
+    completedAt: evidence.result.completedAt,
+    exitCode: evidence.result.exitCode,
+    signal: evidence.result.signal,
+    cleanup: evidence.result.cleanup
+  };
+}
+
+function validateManualValidationEvidence(value: unknown, expected?: ManualValidationEvidenceIdentity): ManualValidationEvidenceResult {
+  const shape = validateShape(value);
+  if (!shape.ok) return shape;
+  const evidence = shape.value;
+  if (evidence.result.exitCode !== 0 || evidence.result.signal !== null || evidence.result.cleanup !== 'completed') {
+    return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_UNSUCCESSFUL', message: 'validation must exit 0 without a signal and complete cleanup' } };
+  }
+  if (expected) {
+    if (evidence.taskId !== expected.taskId || evidence.branch !== expected.branch) {
+      return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_IDENTITY_MISMATCH', message: 'evidence task or branch does not match the expected identity' } };
+    }
+    if (expected.commit !== undefined && evidence.commit !== expected.commit) {
+      return { ok: false, error: { code: 'MANUAL_VALIDATION_EVIDENCE_STALE', message: 'evidence commit does not match the current head' } };
+    }
+  }
+  return shape;
+}
+
+function readManualValidationEvidence(file: string, expected?: ManualValidationEvidenceIdentity): ManualValidationEvidenceResult {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code === 'ENOENT'
+      ? 'MANUAL_VALIDATION_EVIDENCE_MISSING'
+      : 'MANUAL_VALIDATION_EVIDENCE_INVALID';
+    return { ok: false, error: { code, message: error instanceof Error ? error.message : String(error) } };
+  }
+  return validateManualValidationEvidence(parsed, expected);
+}
+
+function manualValidationEvidenceDigest(evidence: ManualValidationEvidence): string {
+  return createHash('sha256').update(JSON.stringify(evidence), 'utf8').digest('hex');
+}
+
+export {
+  MANUAL_VALIDATION_EVIDENCE_SCHEMA,
+  MANUAL_VALIDATION_EVIDENCE_VERSION,
+  createManualValidationEvidence,
+  manualValidationEvidenceSummary,
+  manualValidationEvidenceDigest,
+  readManualValidationEvidence,
+  validateManualValidationEvidence
+};
+export type {
+  ManualValidationCleanup,
+  ManualValidationEvidence,
+  ManualValidationEvidenceError,
+  ManualValidationEvidenceErrorCode,
+  ManualValidationEvidenceIdentity,
+  ManualValidationEvidenceInput,
+  ManualValidationEvidenceResult,
+  ManualValidationEvidenceSummary,
+  ManualValidationMode,
+  ManualValidationScope
+};

package/lib/task/manual-validation-receipt.ts

@@ -0,0 +1,156 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import {
+  MANUAL_VALIDATION_ARTIFACT as ARTIFACT,
+  MANUAL_VALIDATION_SHA40 as SHA40,
+  MANUAL_VALIDATION_SHA64 as SHA64,
+  MANUAL_VALIDATION_TASK_ID as TASK_ID,
+  exactKeys,
+  isRecord,
+  validTimestamp,
+  writeJsonAtomic
+} from './manual-validation-shared.ts';
+
+const MANUAL_VALIDATION_RECEIPT_SCHEMA = 'agent-infra/manual-validation-receipt';
+const MANUAL_VALIDATION_RECEIPT_VERSION = 1;
+
+type ManualValidationReceipt = Readonly<{
+  schema: typeof MANUAL_VALIDATION_RECEIPT_SCHEMA;
+  version: typeof MANUAL_VALIDATION_RECEIPT_VERSION;
+  transactionId: string;
+  taskId: string;
+  prNumber: number;
+  prHeadSha: string;
+  evidenceDigest: string;
+  artifact: string;
+  artifactSha256: string;
+  pendingSummaryDigest: string;
+  finalSummaryDigest: string;
+  committedAt: string;
+  receiptDigest: string;
+}>;
+type ManualValidationReceiptInput = Omit<ManualValidationReceipt, 'schema' | 'version' | 'receiptDigest'>;
+type ManualValidationReceiptErrorCode =
+  | 'MANUAL_VALIDATION_RECEIPT_MISSING'
+  | 'MANUAL_VALIDATION_RECEIPT_INVALID'
+  | 'MANUAL_VALIDATION_RECEIPT_IDENTITY_MISMATCH';
+type ManualValidationReceiptError = { code: ManualValidationReceiptErrorCode; message: string };
+type ManualValidationReceiptResult =
+  | { ok: true; value: ManualValidationReceipt }
+  | { ok: false; error: ManualValidationReceiptError };
+type ManualValidationReceiptIdentity = Partial<Pick<ManualValidationReceipt, 'transactionId' | 'taskId' | 'prNumber' | 'prHeadSha' | 'evidenceDigest' | 'artifact'>>;
+
+function invalid(message: string): ManualValidationReceiptResult {
+  return { ok: false, error: { code: 'MANUAL_VALIDATION_RECEIPT_INVALID', message } };
+}
+
+function canonicalPayload(receipt: ManualValidationReceipt | ManualValidationReceiptInput): Omit<ManualValidationReceipt, 'receiptDigest'> {
+  return {
+    schema: MANUAL_VALIDATION_RECEIPT_SCHEMA,
+    version: MANUAL_VALIDATION_RECEIPT_VERSION,
+    transactionId: receipt.transactionId,
+    taskId: receipt.taskId,
+    prNumber: receipt.prNumber,
+    prHeadSha: receipt.prHeadSha,
+    evidenceDigest: receipt.evidenceDigest,
+    artifact: receipt.artifact,
+    artifactSha256: receipt.artifactSha256,
+    pendingSummaryDigest: receipt.pendingSummaryDigest,
+    finalSummaryDigest: receipt.finalSummaryDigest,
+    committedAt: receipt.committedAt
+  };
+}
+
+function manualValidationReceiptDigest(receipt: ManualValidationReceipt | ManualValidationReceiptInput): string {
+  return createHash('sha256').update(JSON.stringify(canonicalPayload(receipt)), 'utf8').digest('hex');
+}
+
+function manualValidationFinalSummaryDigest(body: string): string {
+  const heading = /^###\s+✅\s+(?:Manual Validation Passed|人工验证已通过)\s*$/mu.exec(body);
+  const afterHeading = heading ? body.slice(heading.index + heading[0].length) : '';
+  const nextSection = heading ? /^#{1,3}\s/mu.exec(afterHeading) : null;
+  const projection = heading
+    ? body.slice(heading.index, heading.index + heading[0].length + (nextSection?.index ?? afterHeading.length)).replace(/\s+$/u, '')
+    : body;
+  const preimage = projection.replace(/receipt=(?:[a-f0-9]{64}|<receipt>)/gu, 'receipt=<receipt>');
+  return createHash('sha256').update(preimage, 'utf8').digest('hex');
+}
+
+function manualValidationFinalSummaryProjectionMatches(body: string, receipt: ManualValidationReceipt): boolean {
+  const identity = `transaction=${receipt.transactionId}; receipt=${receipt.receiptDigest}; evidence=${receipt.evidenceDigest}; head=${receipt.prHeadSha}`;
+  return body.includes(identity) && manualValidationFinalSummaryDigest(body) === receipt.finalSummaryDigest;
+}
+
+function validateManualValidationReceipt(value: unknown, expected?: ManualValidationReceiptIdentity): ManualValidationReceiptResult {
+  if (!isRecord(value)) return invalid('receipt must be a JSON object');
+  const keys = ['schema', 'version', 'transactionId', 'taskId', 'prNumber', 'prHeadSha', 'evidenceDigest', 'artifact', 'artifactSha256', 'pendingSummaryDigest', 'finalSummaryDigest', 'committedAt', 'receiptDigest'];
+  const keyError = exactKeys(value, keys, 'receipt');
+  if (keyError) return invalid(keyError);
+  if (value.schema !== MANUAL_VALIDATION_RECEIPT_SCHEMA || value.version !== MANUAL_VALIDATION_RECEIPT_VERSION) return invalid('receipt schema or version is unsupported');
+  if (typeof value.transactionId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(value.transactionId)) return invalid('transactionId is invalid');
+  if (typeof value.taskId !== 'string' || !TASK_ID.test(value.taskId)) return invalid('taskId is invalid');
+  const prNumber = value.prNumber;
+  if (!Number.isSafeInteger(prNumber) || (prNumber as number) <= 0) return invalid('prNumber is invalid');
+  for (const [name, pattern] of [['prHeadSha', SHA40], ['evidenceDigest', SHA64], ['artifactSha256', SHA64], ['pendingSummaryDigest', SHA64], ['finalSummaryDigest', SHA64], ['receiptDigest', SHA64]] as const) {
+    if (typeof value[name] !== 'string' || !pattern.test(value[name])) return invalid(`${name} is invalid`);
+  }
+  if (typeof value.artifact !== 'string' || !ARTIFACT.test(value.artifact)) return invalid('artifact is not a canonical manual-validation artifact');
+  if (!validTimestamp(value.committedAt)) return invalid('committedAt is invalid');
+  const receipt = value as unknown as ManualValidationReceipt;
+  if (manualValidationReceiptDigest(receipt) !== receipt.receiptDigest) return invalid('receiptDigest does not match receipt contents');
+  if (expected && Object.entries(expected).some(([key, expectedValue]) => expectedValue !== undefined && receipt[key as keyof ManualValidationReceipt] !== expectedValue)) {
+    return { ok: false, error: { code: 'MANUAL_VALIDATION_RECEIPT_IDENTITY_MISMATCH', message: 'receipt identity does not match the expected transaction' } };
+  }
+  return { ok: true, value: receipt };
+}
+
+function createManualValidationReceipt(input: ManualValidationReceiptInput): ManualValidationReceipt {
+  const payload = canonicalPayload(input);
+  const receipt = { ...payload, receiptDigest: manualValidationReceiptDigest(input) };
+  const checked = validateManualValidationReceipt(receipt);
+  if (!checked.ok) throw new Error(`${checked.error.code}: ${checked.error.message}`);
+  return checked.value;
+}
+
+function manualValidationReceiptPath(taskDir: string): string {
+  return path.join(taskDir, '.manual-validation', 'receipt.json');
+}
+
+function writeManualValidationReceiptAtomic(taskDir: string, receipt: ManualValidationReceipt): string {
+  const checked = validateManualValidationReceipt(receipt);
+  if (!checked.ok) throw new Error(`${checked.error.code}: ${checked.error.message}`);
+  const target = manualValidationReceiptPath(taskDir);
+  return writeJsonAtomic(target, receipt);
+}
+
+function readManualValidationReceipt(taskDir: string, expected?: ManualValidationReceiptIdentity): ManualValidationReceiptResult {
+  const file = manualValidationReceiptPath(taskDir);
+  let value: unknown;
+  try { value = JSON.parse(fs.readFileSync(file, 'utf8')) as unknown; }
+  catch (error) {
+    return { ok: false, error: { code: (error as NodeJS.ErrnoException).code === 'ENOENT' ? 'MANUAL_VALIDATION_RECEIPT_MISSING' : 'MANUAL_VALIDATION_RECEIPT_INVALID', message: error instanceof Error ? error.message : String(error) } };
+  }
+  return validateManualValidationReceipt(value, expected);
+}
+
+export {
+  MANUAL_VALIDATION_RECEIPT_SCHEMA,
+  MANUAL_VALIDATION_RECEIPT_VERSION,
+  createManualValidationReceipt,
+  manualValidationFinalSummaryDigest,
+  manualValidationFinalSummaryProjectionMatches,
+  manualValidationReceiptDigest,
+  manualValidationReceiptPath,
+  readManualValidationReceipt,
+  validateManualValidationReceipt,
+  writeManualValidationReceiptAtomic
+};
+export type {
+  ManualValidationReceipt,
+  ManualValidationReceiptError,
+  ManualValidationReceiptErrorCode,
+  ManualValidationReceiptIdentity,
+  ManualValidationReceiptInput,
+  ManualValidationReceiptResult
+};

package/lib/task/manual-validation-shared.ts

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const MANUAL_VALIDATION_TASK_ID = /^TASK-\d{8}-\d{6}$/u;
+const MANUAL_VALIDATION_SHA40 = /^[a-f0-9]{40}$/u;
+const MANUAL_VALIDATION_SHA64 = /^[a-f0-9]{64}$/u;
+const MANUAL_VALIDATION_ARTIFACT = /^manual-validation(?:-r[2-9]|-r[1-9]\d+)?.md$/u;
+const MANUAL_VALIDATION_TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function exactKeys(value: Record<string, unknown>, keys: readonly string[], label: string): string | null {
+  const allowed = new Set(keys);
+  const unknown = Object.keys(value).find((key) => !allowed.has(key));
+  if (unknown) return `${label} contains unknown field '${unknown}'`;
+  const missing = keys.find((key) => !Object.hasOwn(value, key));
+  return missing ? `${label} is missing '${missing}'` : null;
+}
+
+function validTimestamp(value: unknown): value is string {
+  return typeof value === 'string' && MANUAL_VALIDATION_TIMESTAMP.test(value) && Number.isFinite(Date.parse(value));
+}
+
+function writeJsonAtomic(file: string, value: unknown): string {
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  try {
+    fs.writeFileSync(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, file);
+  } catch (error) {
+    try { fs.unlinkSync(temporary); } catch { /* best effort cleanup of our own temp file */ }
+    throw error;
+  }
+  return file;
+}
+
+export {
+  MANUAL_VALIDATION_ARTIFACT,
+  MANUAL_VALIDATION_SHA40,
+  MANUAL_VALIDATION_SHA64,
+  MANUAL_VALIDATION_TASK_ID,
+  MANUAL_VALIDATION_TIMESTAMP,
+  exactKeys,
+  isRecord,
+  validTimestamp,
+  writeJsonAtomic
+};