@sanning/proof 0.12.0 → 0.14.0

package/src/grading.ts

@@ -41,13 +41,13 @@
 //               presents a different number of records than a checkpoint
 //               signed for — UNKNOWN
 //
-// `incomplete` is the surface's word for undetermined, and it is deliberately
-// NOT `verdict.status` from `evidence-bundle.md` §3. That enum grades a signed
-// bundle; this one grades a PACK — a strictly larger object, the bundle plus
-// whatever bytes travelled beside it. A pack can be incomplete while the bundle
-// it carries is impeccable, which is exactly the case that used to render green
-// over zero hashed bytes. Widening §3 to carry `incomplete` would be a spec
-// change; keeping the two enums distinct is not.
+// `incomplete` is one of the eight words of `evidence-bundle.md` §3 (v1.17,
+// A18), and it is a PACK verdict, never a bundle status. The bundle status
+// grades a signed bundle; this grades a PACK — a strictly larger object, the
+// bundle plus whatever bytes travelled beside it. A pack can be incomplete
+// while the bundle it carries is impeccable, which is exactly the case that
+// used to render green over zero hashed bytes. One vocabulary, two layers,
+// each issuing the subset it can reach.
 //
 // `recordsVerified` counts CONTENT-BOUND records only. The kernel's own
 // `event.ok` tolerates undisclosed content by design — a bundle may legitimately
@@ -86,15 +86,17 @@ import { jcsParse } from "./verifier.js";
 // A superset of `EvidenceStatus`: the four the kernel can return, plus the
 // pack-level `incomplete`, plus `pending` from the shared §3 vocabulary so a
 // kernel headline this module does not downgrade can pass through unchanged.
-export type PackVerdict =
-  | "verified"
-  | "partial"
-  | "pending"
-  | "not_found"
-  | "mixed"
-  | "failed"
-  | "malformed"
-  | "incomplete";
+export const PACK_VERDICTS = [
+  "verified",
+  "partial",
+  "pending",
+  "not_found",
+  "mixed",
+  "failed",
+  "malformed",
+  "incomplete",
+] as const;
+export type PackVerdict = (typeof PACK_VERDICTS)[number];
 
 // ---- Inputs ------------------------------------------------------------------
 
@@ -109,7 +111,17 @@ export type PackVerdict =
  */
 export interface GradeInput {
   status: string | null | undefined;
-  events: { ok: boolean; contentOk: boolean | null }[];
+  /**
+   * `eventId` and `payloadBindingOk` are read by rule version 6 alone (A22):
+   * an input that does not carry both is never withheld by its declaration,
+   * so an adapter written for rule version 5 keeps the stricter reading.
+   */
+  events: {
+    ok: boolean;
+    contentOk: boolean | null;
+    eventId?: string;
+    payloadBindingOk?: boolean | null;
+  }[];
 }
 
 /**
@@ -144,21 +156,23 @@ export type CompletenessNote =
 
 // ---- Output ------------------------------------------------------------------
 
-export type PackGradeCauseKind =
-  | "records-omitted"
-  | "records-surplus"
-  | "leaf-count-unreadable"
-  | "no-disclosure"
-  | "missing-disclosure"
-  | "unreadable-disclosure"
-  | "unaccounted-disclosure"
-  | "declaration-deviation"
+export const PACK_GRADE_CAUSE_KINDS = [
+  "records_omitted",
+  "records_surplus",
+  "leaf_count_unreadable",
+  "no_disclosure",
+  "missing_disclosure",
+  "unreadable_disclosure",
+  "unaccounted_disclosure",
+  "declaration_deviation",
   /**
    * The pack and the UNSIGNED content handed in beside it do not line up
    * (proof#147). A cause, so the pack cannot read clean over it and a reader
    * is told which record; NOT a deviation, so it never reaches `failed`.
    */
-  | "declaration-content-dependent";
+  "declaration_content_dependent",
+] as const;
+export type PackGradeCauseKind = (typeof PACK_GRADE_CAUSE_KINDS)[number];
 
 /**
  * One reason a pack is not `verified`, as data.
@@ -186,8 +200,8 @@ export interface PackGradeCause {
   reason?: string;
   /**
    * Which deviation from the pack's own declaration, for
-   * `declaration-deviation`, or which content-dependent finding, for
-   * `declaration-content-dependent`.
+   * `declaration_deviation`, or which content-dependent finding, for
+   * `declaration_content_dependent`.
    */
   deviation?: DeclarationDeviationKind | DeclarationContentKind;
 }
@@ -205,6 +219,17 @@ export interface PackGrade {
    * check was passed, which is the pre-§5.4 call.
    */
   declaration?: DeclarationVerdict;
+  /**
+   * Records WITHHELD BY THEIR DECLARATION (rule version 6, evidence-bundle
+   * 5.4.5 v1.20, A22): a readable declaration lists them in
+   * `declaredWithheld`, their `ok` is true, their `contentOk` is `null` and
+   * their `payloadBindingOk` is true. Never counted in `recordsVerified`: no
+   * byte of their content was hashed, and a surface MUST NOT print them as
+   * verified records.
+   */
+  recordsWithheld: number;
+  /** Their `event_id`s, in bundle order. */
+  withheldEventIds: string[];
 }
 
 // ---- Reading a bundle --------------------------------------------------------
@@ -522,7 +547,20 @@ export function gradeCauses(
   account: DisclosureAccount,
   notes: readonly CompletenessNote[],
   declaration?: DeclarationCheck | null,
+  withheld: readonly string[] = [],
 ): PackGradeCause[] {
+  // The `event_id`s WITHHELD BY THEIR DECLARATION (rule version 6) are taken
+  // out of `expected` and `missing` before the disclosure causes are computed,
+  // so a pack whose every record its declaration withholds earns neither
+  // `no_disclosure` nor `missing_disclosure`.
+  if (withheld.length > 0) {
+    const gone = new Set(withheld);
+    account = {
+      ...account,
+      expected: account.expected.filter((e) => !gone.has(e)),
+      missing: account.missing.filter((e) => !gone.has(e)),
+    };
+  }
   const causes: PackGradeCause[] = [];
 
   // What the pack CLAIMED to hold comes first, because it frames everything
@@ -532,7 +570,7 @@ export function gradeCauses(
   // four ways can never be reported as one vague shortfall.
   for (const deviation of declaration?.deviations ?? []) {
     causes.push({
-      kind: "declaration-deviation",
+      kind: "declaration_deviation",
       deviation: deviation.kind,
       ...(deviation.eventId === undefined ? {} : { firstEventId: deviation.eventId }),
       reason: renderDeviation(deviation),
@@ -544,7 +582,7 @@ export function gradeCauses(
   // deviation, so it never reaches `failed`.
   for (const finding of declaration?.contentFindings ?? []) {
     causes.push({
-      kind: "declaration-content-dependent",
+      kind: "declaration_content_dependent",
       deviation: finding.kind,
       ...(finding.eventId === undefined ? {} : { firstEventId: finding.eventId }),
       reason: renderContentFinding(finding),
@@ -554,7 +592,7 @@ export function gradeCauses(
   for (const note of notes) {
     if (note.kind === "omitted") {
       causes.push({
-        kind: "records-omitted",
+        kind: "records_omitted",
         checkpointRef: note.checkpointRef,
         signed: note.signed,
         presented: note.presented,
@@ -562,14 +600,14 @@ export function gradeCauses(
       });
     } else if (note.kind === "surplus") {
       causes.push({
-        kind: "records-surplus",
+        kind: "records_surplus",
         checkpointRef: note.checkpointRef,
         signed: note.signed,
         presented: note.presented,
         count: note.presented - note.signed,
       });
     } else {
-      causes.push({ kind: "leaf-count-unreadable", checkpointRef: note.checkpointRef });
+      causes.push({ kind: "leaf_count_unreadable", checkpointRef: note.checkpointRef });
     }
   }
 
@@ -578,10 +616,10 @@ export function gradeCauses(
   // reader deserves to be told the pack disclosed nothing rather than counting
   // N absences.
   if (account.expected.length > 0 && account.present.length === 0 && account.unreadable.length === 0) {
-    causes.push({ kind: "no-disclosure", count: account.expected.length, of: account.expected.length });
+    causes.push({ kind: "no_disclosure", count: account.expected.length, of: account.expected.length });
   } else if (account.missing.length > 0) {
     causes.push({
-      kind: "missing-disclosure",
+      kind: "missing_disclosure",
       count: account.missing.length,
       of: account.expected.length,
       ...(account.missing[0] === undefined ? {} : { firstEventId: account.missing[0] }),
@@ -589,12 +627,12 @@ export function gradeCauses(
   }
 
   for (const u of account.unreadable) {
-    causes.push({ kind: "unreadable-disclosure", firstEventId: u.eventId, reason: u.reason });
+    causes.push({ kind: "unreadable_disclosure", firstEventId: u.eventId, reason: u.reason });
   }
 
   if (account.extra.length > 0) {
     causes.push({
-      kind: "unaccounted-disclosure",
+      kind: "unaccounted_disclosure",
       count: account.extra.length,
       ...(account.extra[0] === undefined ? {} : { firstEventId: account.extra[0] }),
     });
@@ -614,7 +652,8 @@ export function gradeCauses(
  * the type and renders the verdict verbatim would then print the one word
  * `evidence-bundle.md` §6 forbids, over a pack this rule never graded.
  *
- * So: the six states of the §3 vocabulary pass through, and ANYTHING ELSE is
+ * So: the five words of the §3 vocabulary that a bundle status can pass up to
+ * a pack pass through, and ANYTHING ELSE is
  * `incomplete`. A verdict we cannot interpret is a check we could not run, and
  * the answer to that is UNKNOWN — never a pass, and never an accusation.
  * (`failed` and `malformed` are handled before this is reached.)
@@ -637,8 +676,9 @@ function passThrough(status: string | null | undefined): PackVerdict {
  * The verdict a surface may print, and the counts it may print beside it.
  *
  * The invariant, stated so a mutation test can kill it: `verified` is reachable
- * ONLY when every record's supplied bytes bound to its own commitment and
- * nothing is missing, unreadable, surplus or omitted.
+ * ONLY when every record's supplied bytes bound to its own commitment, or
+ * (rule version 6) the record is withheld by its declaration, and nothing is
+ * missing, unreadable, surplus or omitted.
  *
  * Precedence: malformed > failed > incomplete > the kernel's own headline.
  * A hard verdict wins — "the bytes are absent" is never reported as failure
@@ -696,8 +736,23 @@ export function gradePack(
   const events = Array.isArray(result?.events) ? result.events : [];
   const recordsVerified = events.filter((e) => e.ok && e.contentOk === true).length;
   const recordsFailed = events.filter((e) => e.ok === false || e.contentOk === false).length;
-  const recordsUndetermined = events.length - recordsVerified - recordsFailed;
-  const causes = gradeCauses(account, notes, declaration);
+  // WITHHELD BY ITS DECLARATION (rule version 6, 5.4.5 v1.20, A22, D5). All
+  // four conditions, each on its own. `declaredWithheld` is empty for an
+  // absent, unreadable or malformed declaration.
+  const declaredWithheld = new Set(declaration?.declaredWithheld ?? []);
+  const withheldEventIds = events
+    .filter(
+      (e) =>
+        typeof e.eventId === "string" &&
+        declaredWithheld.has(e.eventId) &&
+        e.ok === true &&
+        e.contentOk === null &&
+        e.payloadBindingOk === true,
+    )
+    .map((e) => e.eventId as string);
+  const recordsWithheld = withheldEventIds.length;
+  const recordsUndetermined = events.length - recordsVerified - recordsFailed - recordsWithheld;
+  const causes = gradeCauses(account, notes, declaration, withheldEventIds);
 
   let verdict: PackVerdict;
   if (result?.status === "malformed") verdict = "malformed";
@@ -714,6 +769,8 @@ export function gradePack(
     recordsFailed,
     recordsUndetermined,
     causes,
+    recordsWithheld,
+    withheldEventIds,
   };
   if (declaration != null) grade.declaration = declaration.verdict;
   return grade;
@@ -733,31 +790,31 @@ export function gradePack(
  */
 export function renderCause(cause: PackGradeCause, subject = "this pack"): string {
   switch (cause.kind) {
-    case "records-omitted":
+    case "records_omitted":
       return (
         `checkpoint ${cause.checkpointRef} commits to ${cause.signed} record(s); ${subject} presents ` +
         `${cause.presented} — ${cause.count} record(s) OMITTED`
       );
-    case "records-surplus":
+    case "records_surplus":
       return (
         `checkpoint ${cause.checkpointRef} commits to ${cause.signed} record(s); ${subject} presents ` +
         `${cause.presented} — more records than the signed tree accounts for`
       );
-    case "leaf-count-unreadable":
+    case "leaf_count_unreadable":
       return `checkpoint ${cause.checkpointRef} has no readable signed leaf_count — completeness is UNKNOWN`;
-    case "no-disclosure":
+    case "no_disclosure":
       return (
         `no event bytes were disclosed — content binding is UNKNOWN for all ${cause.count} ` +
         `record(s), not verified`
       );
-    case "missing-disclosure":
+    case "missing_disclosure":
       return (
         `${cause.count} of ${cause.of} record(s) disclose no bytes (first: ${cause.firstEventId}) — ` +
         `content binding is UNKNOWN, not verified`
       );
-    case "unreadable-disclosure":
+    case "unreadable_disclosure":
       return `the disclosure for ${cause.firstEventId} is unreadable: ${cause.reason}`;
-    case "unaccounted-disclosure":
+    case "unaccounted_disclosure":
       return (
         `${cause.count} disclosed file(s) are not accounted for by any record in this bundle ` +
         `(first: ${cause.firstEventId})`
@@ -766,9 +823,9 @@ export function renderCause(cause: PackGradeCause, subject = "this pack"): strin
     // here on `reason`. Re-deriving the sentence from the cause fields would
     // put the declaration's wording in two places, and one of the two would be
     // edited alone.
-    case "declaration-deviation":
+    case "declaration_deviation":
       return `this pack deviates from its own declaration: ${cause.reason}`;
-    case "declaration-content-dependent":
+    case "declaration_content_dependent":
       // Named as what the reader could not establish, never as what the
       // holder did: the bytes it turns on are unsigned and whoever assembled
       // the case chose them (proof#147).

package/src/index.ts

@@ -12,7 +12,7 @@
 // gateway/transport concerns are consumer-layer logic composed above it.
 
 // ACCEPTED_SPEC_MAJORS is exported for parity with the sibling kernels'
-// registries (Python ACCEPTED_SPEC_VERSIONS, Go SupportedSpecMajor): a consumer
+// registries (Python ACCEPTED_SPEC_MAJORS, Go SupportedSpecMajor): a consumer
 // can see which profiles this build admits without inferring it from probe
 // calls. It is frozen at its definition (`Object.freeze`, typed
 // `readonly string[]`) because the verifier reads that same array — an exported
@@ -60,11 +60,14 @@ export type { ContentRole, Envelope, Subject, VerificationResult, VerifyOptions
 // bytes, and only for events whose verification bound them to the committed
 // content_hash. Additive; verifyEvidenceBundle's behavior is unchanged.
 export {
+  ACCEPTED_EVIDENCE_MAJORS,
   ANCHOR_TRACE_BODY_TYPE,
+  CO_SIGNATURES_NOTE,
   EXPORT_BODY_TYPE,
   STAMP_BODY_VERSION,
   STAMP_TRACE_BODY_TYPE,
   STAMP_EVIDENCE_BODY_TYPE,
+  coSignaturesPresent,
   disclosedContent,
   recomputeExportVerdict,
   verifyEvidenceBundle,
@@ -128,6 +131,8 @@ export type {
 // derivation to it, and diff its copy against ours. Additive — no existing
 // export changes.
 export {
+  PACK_GRADE_CAUSE_KINDS,
+  PACK_VERDICTS,
   accountDisclosure,
   completenessNotes,
   gradeCauses,
@@ -162,7 +167,14 @@ export type {
 // optional fourth argument, so a surface gets one verdict; omitting it is the
 // pre-§5.4 behavior, unchanged. Additive: no existing export changes.
 export {
+  DECLARATION_CONTENT_KINDS,
+  DECLARATION_DEVIATION_KINDS,
+  DECLARATION_NOTE_KINDS,
+  DECLARATION_ROLES,
+  DECLARATION_VERDICTS,
   DECLARATION_VERSION,
+  DECLARATION_VERSION_V2,
+  DECLARATION_VERSIONS,
   checkDeclaration,
   declarationClaims,
   packRecords,
@@ -180,6 +192,7 @@ export type {
   DeclarationDeviationKind,
   DeclarationNote,
   DeclarationNoteKind,
+  DeclarationRole,
   DeclarationVerdict,
   PackRecord,
 } from "./declaration.js";
@@ -206,20 +219,94 @@ export {
   CASE_EXCEPTION_KINDS,
   CASE_QUARANTINED_PROFILES,
   CASE_RECORD_PROFILES,
+  CASE_NOTE_KINDS,
+  CASE_RELIANCE,
+  CASE_RELIANCE_HANDOFF_CLAUSE,
   CASE_VERDICTS,
+  CONTENT_WITHHELD_BY_DECLARATION,
+  CO_SIGNATURES_PRESENT,
+  VERDICT_DISPLAY_TITLES,
+  WITNESS_NOT_LOOKED_UP,
+  WITNESS_STATES,
+  WITNESS_TIME_CACHED,
+  WITNESS_TIME_RECORDED,
+  caseReliance,
   readCase,
+  renderCaseNote,
   renderCaseSummary,
   renderException,
+  renderWitnessLine,
 } from "./case.js";
+// The witnessed-time cache (evidence-bundle 5.6.6, v1.25, A30): read it, look it
+// up, print it. Never an input to a verdict.
+export {
+  MAX_BLOCK_TIME,
+  MAX_WITNESS_CACHE_DEPTH,
+  WITNESS_CACHE_NAME,
+  WITNESS_CACHE_VERSION,
+  checkWitnessCache,
+  formatBlockTime,
+  readWitnessCache,
+  renderWitnessTime,
+  witnessTimeQuery,
+} from "./witness-cache.js";
+export type { CachedWitnessTime, WitnessTimeAnswer, WitnessTimeCheck } from "./witness-cache.js";
 export type {
   CaseException,
   CaseExceptionKind,
+  CaseNote,
+  CaseNoteKind,
   CasePack,
+  CasePackReading,
   CaseReading,
   CaseRecordReading,
   CaseVerdict,
+  WitnessLine,
+  WitnessState,
 } from "./case.js";
 
+// The case file's index (src/case-file.ts, evidence-bundle.md §5.6, A25):
+// compared with the drop it describes, with NO verdict contribution. The index
+// is never an input to `readCase`. Pure: bytes and a file list in.
+export {
+  CASE_FILE_FINDING_KINDS,
+  CASE_FILE_INDEX_NAME,
+  CASE_FILE_VERSION,
+  HOW_TO_VERIFY_NAME,
+  REPORT_README_FIRST_LINE,
+  howToVerifyText,
+  isPackRef,
+  readCaseFileIndex,
+  renderCaseFileFinding,
+} from "./case-file.js";
+export type {
+  CaseFileFinding,
+  CaseFileFindingKind,
+  CaseFileIndexReading,
+} from "./case-file.js";
+
+// Files handed in beside a pack (src/file-match.ts, evidence-bundle.md §5.7,
+// A29, proof#92): each file's SHA-256 matched against the commitments the
+// pack's SIGNED records make, by hash alone. Never moves a verdict.
+export {
+  FILE_MATCH_SCOPE,
+  NOT_READ_REASONS,
+  fileMatchToJson,
+  matchCaseFiles,
+  matchFiles,
+  renderFileMatch,
+} from "./file-match.js";
+export type {
+  FileCommitment,
+  FileMatchPack,
+  FileMatchReading,
+  MatchedFile,
+  NotRead,
+  NotReadReason,
+  OfferedFile,
+  UnmatchedFile,
+} from "./file-match.js";
+
 // Chain reading (src/chain.ts): following the pointer every sanning.events/v2
 // record carries to the record before it, over the records ONE bundle presents.
 //
@@ -258,13 +345,25 @@ export type {
 // signed, offline-verifiable sanning.evidence.export/v2 artifact from a source
 // anchor-trace bundle + operator attestations + an exporter Ed25519 key. The
 // inverse of verifyEvidenceBundle's verifyExportBody dispatch.
+// One exit-code table for every verb (0.13.0): the verdict word to the exit
+// code, and the help text every verb prints. Additive.
+export {
+  EXIT_CODES,
+  EXIT_CODES_HELP,
+  EXIT_FAILED,
+  EXIT_MALFORMED,
+  EXIT_MIXED,
+  EXIT_UNDETERMINED,
+  EXIT_VERIFIED,
+  exitCodeFor,
+} from "./exit-codes.js";
 export { attestationSignatureToHex, composeExport } from "./compose.js";
 export type { ComposeExportOptions, ComposeExportResult, ExporterKey } from "./compose.js";
 
 // Agent inclusion-proof bundle verification: the
 // sanning.agent.proof/v1 bundle. The CLI sniffs spec_version and routes here so
 // one verifier covers both agent and anchor bundles.
-export { AGENT_PROOF_SPEC_PREFIX, isAgentProofSpec, verifyAgentProofBundle } from "./agent-proof.js";
+export { AGENT_PROOF_SPEC_VERSION, isAgentProofSpec, verifyAgentProof } from "./agent-proof.js";
 export type {
   AgentProofBundle,
   AgentProofResult,

package/src/message-parts.ts

@@ -278,23 +278,33 @@ const HELD_UNCHECKED_RESULTS: readonly string[] = [
 
 /**
  * The keys that make a part carry its content INLINE, in the order they are
- * read. Named rather than inferred: `bytes` is A2A's spelling of an inline file
- * part, and `data` and `content` are the two other spellings in the wild. The
- * FIRST of them present with a value that is not `null` is the inline content,
- * so a part spelling it twice reads one way in both kernels.
+ * read. Settled at `bytes` alone (envelope-spec §4.1, A31, proof#163): that
+ * is A2A's spelling, the one the wedge actually emits, and it is the only
+ * inline spelling either reference kernel has read from a real producer.
+ * `content` and `data` were added on inference rather than on an observed
+ * wire shape, and sanning-io/anchor's `filePart()` and `file_part()` SDK
+ * helpers, the only producer this plane ships, confirm the inference was
+ * wrong: both emit a descriptor part, `kind: "file"` plus `content_hash` and
+ * `content_length`, and neither ever writes a `content` or `data` wire key
+ * for inline bytes. None is A2A 1.0.0's either: its `Part` has no `kind` and
+ * carries a file as `raw` or `url`, so a literal A2A part reads
+ * `part_not_a_file` (envelope-spec §4.1, A19). The one key present with a
+ * value that is not `null` is the inline content.
  *
  * A key present with `null` is an ABSENT inline value, on A14's ruling that an
- * absent value and one written as `null` name one thing. That matters: an A2A
- * `FilePart` with `uri` set carries `"bytes": null`, and so does proto3 JSON,
- * and reading those as inline made a conformant DESCRIPTOR part uncheckable
- * (proof#156 gate). They fall through to the descriptor rule, which is what
- * they are.
- */
-// A conformant DESCRIPTOR part that also carries a `content` or `data` key
-// meaning something else (a filename, a metadata blob) is reclassified by this
-// list and never checked against supplied bytes. That is inside section 4.1's
-// stated rule, and whether these parts ought to fall into it is proof#163.
-export const INLINE_BYTES_KEYS = ["bytes", "content", "data"] as const;
+ * absent value and one written as `null` name one thing. That matters: a
+ * proto3 JSON encoder can write an unset field as `"bytes": null`, and reading
+ * that as inline made a conformant DESCRIPTOR part uncheckable
+ * (proof#156 gate). Such a part falls through to the descriptor rule, which is
+ * what it is.
+ */
+// Before A31 this list also carried `content` and `data`, and a conformant
+// DESCRIPTOR part that happened to carry either key meaning something else (a
+// filename, a caption) was silently reclassified as inline and never checked
+// against supplied bytes: the swapped-bytes check A18 exists to run
+// (proof#145) never ran on it. proof#163 is resolved by narrowing to `bytes`
+// alone, closing that gap.
+export const INLINE_BYTES_KEYS = ["bytes"] as const;
 
 const HEX64 = /^[0-9a-fA-F]{64}$/;
 const HEX_CHARSET = /^[0-9a-fA-F]+$/;

package/src/types.ts

@@ -48,6 +48,11 @@ export interface VerifyOptions {
   // Content bind: the caller's own hash of an artifact (e.g. the in-browser
   // hash of a user's file) to match against the hashes the envelope commits to.
   expectedContentHash?: string;
+  // NARROWS the accept-set for this call and never widens it: the set used is
+  // `ACCEPTED_SPEC_MAJORS` intersected with this list, so a caller cannot
+  // admit a profile this kernel does not. The Python twin is
+  // `accepted_spec_majors` (P-10, 0.13.0).
+  acceptedSpecMajors?: readonly string[];
 }
 
 export interface VerificationResult {