government

commit c3dee802a4878505a60909c4f533fffbdfffc936

tree

parent:
bf971275d54b7235006309f4e84fd06723f4f70e

nmyk <nick@nmyk.io>

2026-11-14T20:16:15-05:00

only repeal depth 1

diff --git a/DESIGN.md b/DESIGN.md
index acb20611de1719bca7cfb24cf92ac763789d9d91..660f6cbd9f5e5dfe7fabff5359f3a6e5cc32f2a6 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -333,7 +333,7 @@ | `government verify prog.gov` | Ratify and decode only; print the certificate of ratification; exit 0 if the program is lawful |
 | `government tree prog.gov` | Print the policy tree, with `GOV` abbreviated, payloads decoded and notes shown |
 | `government decompile prog.gov` | Print equivalent Lisp source, notes restored as comments |
 | `government compile prog.gov.lisp -o prog.gov` | Run the transpiler (`-key`, `-author`, `-seed`, `-effective`, `-expires`, `-name`, `-source`) |
-| `government repeal prog.gov -depth i -o repeal.crl` | Write a CRL repealing depth i (`-key` or `-seed`, `-reason`, `-at`, `-issued`, `-next-update`; `-next-update` defaults to 9999-12-31, a permanent repeal) |
+| `government repeal prog.gov -o repeal.crl` | Write a CRL repealing the program (`-key` or `-seed`, `-reason`, `-at`, `-issued`, `-next-update`; `-next-update` defaults to 9999-12-31, a permanent repeal) |
 
 Shared flags: `-at <RFC 3339 time>`, `-anchor <cert or public key PEM>`, `-crl <file>` (repeatable), `-max-nodes <n>`.
 
@@ -413,11 +413,12 @@ ### Repeal (revocation)
 
 A signed certificate revocation list (CRL) can strike down a ratified program after it has shipped.
 
-- Revoking cert *i* repeals depth *i*, and with it the whole program.
-- Per RFC 5280, a cert's revocation is published by its issuer. So depth *i* is repealed by a CRL signed by cert *i−1* (the anchor for depth 1). Every CA cert therefore gets `cRLSign` as well as `keyCertSign`.
-- `government repeal prog.gov -depth 3 -reason superseded -o repeal.crl` writes that CRL. It needs the program's signing key (see Authorship). The reason is any RFC 5280 CRLReason, e.g. `superseded` or `cessationOfOperation`.
+- Revoking any cert of the chain breaks it, so revoking one cert repeals the whole program.
+- Per RFC 5280, a cert's revocation is published by its issuer. `government repeal` always revokes depth 1, so its CRL is signed by the anchor, with the author's own key: the author strikes down what they ratified.
+- `government repeal prog.gov -reason superseded -o repeal.crl` writes that CRL. It needs the program's signing key (see Authorship). The reason is any RFC 5280 CRLReason, e.g. `superseded` or `cessationOfOperation`.
+- The checker accepts a CRL from any cert of the chain, as RFC 5280 path validation does, so a hand-made CRL for depth *i*, signed by cert *i−1*, repeals the program too. Every CA cert therefore gets `cRLSign` as well as `keyCertSign`.
 - `government run -crl repeal.crl prog.gov` loads one or more CRL PEM blocks (the flag repeats; `verify`, `tree` and `decompile` take it too). For each CRL it checks that its issuer is a cert of this program (else `E-FOREIGN`), its signature (`RevocationList.CheckSignatureFrom`, else `E-TAMPERED`), and that the check time is not past `nextUpdate`. A check time before `thisUpdate` is allowed: each entry's revocation time already says when the repeal applies, so a newer list can still answer whether the program was in force at an earlier `-at`.
-- A path cert listed with a revocation time at or before the check time fails: `E-REPEALED: depth 3 repealed 2027-03-01 (superseded)`.
+- A path cert listed with a revocation time at or before the check time fails: `E-REPEALED: depth 1 repealed 2027-03-01 (superseded)`.
 - A CRL past its `nextUpdate` is `E-STALE-REPEALS`. This is a deliberate GOVERNMENT rule: an outdated repeal list fails closed.
 - A future revocation time gives a scheduled repeal. RFC 5280 treats that field as when revocation occurred, so honoring a future time is a GOVERNMENT-specific reading, noted as such.
 - CRLs are always external files. A `.gov` file may still contain only certificates.
diff --git a/PLAN.md b/PLAN.md
index 6898af1ac057aced46dd8a6ca2a39e947a4320c2..e91f31c3966c1dbe319063284bfee15a501bab74 100644
--- a/PLAN.md
+++ b/PLAN.md
@@ -207,9 +207,9 @@     - Build: `-key` (Ed25519 PKCS#8), `-author "Name <email>"` into the anchor subject and subjectAltName, per-depth key derivation SHA-256(seed ‖ "GOVERNMENT" ‖ i), the `-effective` and `-expires` flags; `verify` reports "ratified by nobody in particular" for the default seed.
     - Learn: private keys, PKCS#8, and key derivation; why the default seed being public makes every default-built program forgeable.
     - Done when: two authors' builds of one source differ only in keys and names, each verifies with its own `-anchor` pin, and neither verifies with the other's.
 35. **Writing repeals** (`cmd/government`)
-    - Build: `government repeal prog.gov -depth i`: re-derive the key of cert *i−1*, then `x509.CreateRevocationList` listing serial *i+1* with a CRLReason, `thisUpdate`, `nextUpdate` and a revocation time. Every CA cert gains `cRLSign` in its keyUsage.
-    - Learn: CRLs, why the issuer (not the anchor) revokes, serial numbers being unique only per issuer, reason codes. Read RFC 5280 §5.
-    - Done when: `openssl crl -text` prints your CRL, and its signature verifies against cert *i−1*.
+    - Build: `government repeal prog.gov`: re-derive the anchor key, then `x509.CreateRevocationList` listing the serial of cert 1 with a CRLReason, `thisUpdate`, `nextUpdate` and a revocation time. Every CA cert gains `cRLSign` in its keyUsage.
+    - Learn: CRLs, why a cert is revoked by its own issuer, serial numbers being unique only per issuer, reason codes. Read RFC 5280 §5.
+    - Done when: `openssl crl -text` prints your CRL, and its signature verifies against the anchor.
 36. **Checking repeals** (`ratify`)
     - Build: `-crl` (repeatable); match each CRL to its issuer in the path, verify with `RevocationList.CheckSignatureFrom`, reject if the check time is past `nextUpdate` (`E-STALE-REPEALS`), and reject listed certs whose revocation time has passed (`E-REPEALED`, so future times act as scheduled repeals).
     - Learn: revocation checking as a separate trust decision; fail-open vs fail-closed, and why GOVERNMENT picks fail-closed.
diff --git a/cmd/government/repeal.go b/cmd/government/repeal.go
index 46a72ace76e9414c0ddeb8feded1e811de6e31bb..6a6f6c5be9f81e38cdc11a257b03913194625d81 100644
--- a/cmd/government/repeal.go
+++ b/cmd/government/repeal.go
@@ -12,12 +12,11 @@ 	"government/lisp2gov"
 	"government/ratify"
 )
 
-// repeal writes a CRL that strikes down one depth of a program, and with
-// it the whole program. It needs the key the program was compiled with.
+// repeal writes a CRL that strikes down a program. It needs the key the
+// program was compiled with.
 func repeal(args []string, stdout, stderr io.Writer) int {
 	fs := flag.NewFlagSet("repeal", flag.ContinueOnError)
 	fs.SetOutput(stderr)
-	depth := fs.Int("depth", 0, "repeal the cert at depth `i` (1 to the program's depth)")
 	out := fs.String("o", "", "write the CRL to `file` instead of standard output")
 	keyFile := fs.String("key", "", "the Ed25519 PKCS#8 private key `file` the program was compiled with")
 	seedHex := fs.String("seed", "", "the `hex` seed the program was compiled with, instead of a key file")
@@ -27,7 +26,7 @@ 	fs.Var(&at, "at", "the repeal takes effect at this `time` (default now); a future time schedules it")
 	fs.Var(&issued, "issued", "the CRL's issue `time` (thisUpdate; default now)")
 	fs.Var(&nextUpdate, "next-update", "the CRL goes stale at this `time` (default 9999-12-31T23:59:59Z, never)")
 	fs.Usage = func() {
-		fmt.Fprintln(stderr, "usage: government repeal prog.gov -depth i [-o repeal.crl] [-key file | -seed hex]\n"+
+		fmt.Fprintln(stderr, "usage: government repeal prog.gov [-o repeal.crl] [-key file | -seed hex]\n"+
 			"         [-reason name] [-at time] [-issued time] [-next-update time]")
 		fs.PrintDefaults()
 	}
@@ -68,7 +67,7 @@ 		At:         orDefault(at.t, now),
 		Issued:     orDefault(issued.t, now),
 		NextUpdate: orDefault(nextUpdate.t, time.Date(9999, 12, 31, 23, 59, 59, 0, time.UTC)),
 	}
-	crl, err := lisp2gov.Repeal(certs, *depth, opts)
+	crl, err := lisp2gov.Repeal(certs, opts)
 	if err != nil {
 		fmt.Fprintf(stderr, "%s: %v\n", path, err)
 		return exitInvalid
diff --git a/cmd/government/repeal_test.go b/cmd/government/repeal_test.go
index 3579ec13e08ad969932c26d6a77f72d5ca4ce4ef..484fcac027a324dd704385bc342db6f819053352 100644
--- a/cmd/government/repeal_test.go
+++ b/cmd/government/repeal_test.go
@@ -18,7 +18,7 @@ 	if code, _, stderr := runCmd("compile", src, "-o", gov, "-key", key); code != exitOK {
 		t.Fatal(stderr)
 	}
 	crlPath := filepath.Join(dir, "repeal.crl")
-	code, _, stderr := runCmd("repeal", gov, "-depth", "2", "-key", key, "-reason", "superseded",
+	code, _, stderr := runCmd("repeal", gov, "-key", key, "-reason", "superseded",
 		"-at", "2027-03-01", "-issued", "2027-02-01", "-o", crlPath)
 	if code != exitOK {
 		t.Fatalf("exit %d: %s", code, stderr)
@@ -30,11 +30,11 @@ 	if err != nil {
 		t.Fatal(err)
 	}
 	certs := pemCerts(t, gov)
-	if err := crl.CheckSignatureFrom(certs[1]); err != nil {
-		t.Errorf("CRL does not verify against depth 1, the repealed cert's issuer: %v", err)
+	if err := crl.CheckSignatureFrom(certs[0]); err != nil {
+		t.Errorf("CRL does not verify against the anchor: %v", err)
 	}
 	e := crl.RevokedCertificateEntries[0]
-	if e.SerialNumber.Int64() != 3 || e.ReasonCode != 4 || e.RevocationTime.Format("2006-01-02") != "2027-03-01" {
+	if e.SerialNumber.Cmp(certs[1].SerialNumber) != 0 || e.ReasonCode != 4 || e.RevocationTime.Format("2006-01-02") != "2027-03-01" {
 		t.Errorf("entry: serial %v, reason %d, at %v", e.SerialNumber, e.ReasonCode, e.RevocationTime)
 	}
 }
@@ -50,12 +50,10 @@ 	tests := []struct {
 		args []string
 		want string
 	}{
-		{[]string{"repeal", gov, "-depth", "1", "-key", other}, "did not compile"},
-		{[]string{"repeal", gov, "-depth", "1"}, "did not compile"},
-		{[]string{"repeal", gov, "-depth", "3", "-key", key}, "depths 1 to 2"},
-		{[]string{"repeal", gov, "-key", key}, "depths 1 to 2"},
-		{[]string{"repeal", gov, "-depth", "1", "-key", key, "-reason", "boredom"}, "unknown reason"},
-		{[]string{"repeal", gov, "-depth", "1", "-key", key, "-issued", "2027-01-01", "-next-update", "2026-01-01"}, "go stale"},
+		{[]string{"repeal", gov, "-key", other}, "did not compile"},
+		{[]string{"repeal", gov}, "did not compile"},
+		{[]string{"repeal", gov, "-key", key, "-reason", "boredom"}, "unknown reason"},
+		{[]string{"repeal", gov, "-key", key, "-issued", "2027-01-01", "-next-update", "2026-01-01"}, "go stale"},
 		{[]string{"repeal"}, "usage"},
 	}
 	for _, tt := range tests {
@@ -80,7 +78,7 @@ 	return certs
 }
 
 // TestRepealedProgramIsRefused is the whole round: compile as an author,
-// repeal a depth, and watch every loading command refuse the program.
+// repeal it, and watch every loading command refuse the program.
 func TestRepealedProgramIsRefused(t *testing.T) {
 	dir := t.TempDir()
 	key := writeKey(t, dir, "ada", 1)
@@ -88,7 +86,7 @@ 	src := writeSource(t, "law", "(+ 1 (* 2 3))")
 	gov := filepath.Join(dir, "law.gov")
 	runCmd("compile", src, "-o", gov, "-key", key)
 	crl := filepath.Join(dir, "repeal.crl")
-	if code, _, stderr := runCmd("repeal", gov, "-depth", "1", "-key", key, "-reason", "superseded",
+	if code, _, stderr := runCmd("repeal", gov, "-key", key, "-reason", "superseded",
 		"-at", "2027-03-01", "-issued", "2027-01-01", "-o", crl); code != exitOK {
 		t.Fatal(stderr)
 	}
diff --git a/lisp2gov/repeal.go b/lisp2gov/repeal.go
index 50c7700658406cf6b403ac5f51453ddb6ed4af84..829b9fe17085988cfcfa9d46801bb3c6e7752ee3 100644
--- a/lisp2gov/repeal.go
+++ b/lisp2gov/repeal.go
@@ -12,9 +12,8 @@ )
 
 type RepealOptions struct {
 	// Seed is the key the program was compiled with; nil means
-	// DefaultSeed. Repealing needs it because the cert being repealed is
-	// revoked by its issuer, the cert one depth up, whose key is derived
-	// from this seed.
+	// DefaultSeed. The repeal is signed by the anchor, whose key is this
+	// seed.
 	Seed *[32]byte
 	// Reason is a CRLReason code (see ratify.Reasons).
 	Reason int
@@ -27,30 +26,27 @@ 	// permanent repeal should have a far-off one.
 	Issued, NextUpdate time.Time
 }
 
-// Repeal makes a CRL that revokes the cert at depth of a program, given
-// its certs in depth order. Revoking any one depth breaks the chain, so it
-// repeals the whole program.
-//
-// By RFC 5280 a cert is revoked by its own issuer: the CRL is signed by
-// the cert at depth-1 (the anchor, for depth 1) and names the revoked cert
-// by its serial number, which is unique only among that issuer's certs.
-func Repeal(certs []*x509.Certificate, depth int, opts RepealOptions) ([]byte, error) {
-	n := len(certs) - 1
-	if depth < 1 || depth > n {
-		return nil, fmt.Errorf("depth %d: the program has depths 1 to %d", depth, n)
+// Repeal makes a CRL that repeals a program, given its certs in depth
+// order. Revoking any cert breaks the chain, so one depth is enough; it is
+// always depth 1, the cert the anchor issued, because by RFC 5280 a cert
+// is revoked by its own issuer. The CRL is then signed with the author's
+// own key, and reads as the author striking down what they ratified.
+func Repeal(certs []*x509.Certificate, opts RepealOptions) ([]byte, error) {
+	if len(certs) < 2 {
+		return nil, fmt.Errorf("a program has at least 2 certs, got %d", len(certs))
 	}
 	seed := DefaultSeed
 	if opts.Seed != nil {
 		seed = *opts.Seed
 	}
-	issuer, revoked := certs[depth-1], certs[depth]
-	key := keyForDepth(seed, depth-1)
+	anchor, revoked := certs[0], certs[1]
+	key := keyForDepth(seed, 0)
 	pub, err := x509.MarshalPKIXPublicKey(key.Public())
 	if err != nil {
 		return nil, err
 	}
-	if !bytes.Equal(pub, issuer.RawSubjectPublicKeyInfo) {
-		return nil, fmt.Errorf("this key did not compile the program: depth %d's issuer has a different key", depth)
+	if !bytes.Equal(pub, anchor.RawSubjectPublicKeyInfo) {
+		return nil, fmt.Errorf("this key did not compile the program: the anchor has a different key")
 	}
 	if !opts.NextUpdate.After(opts.Issued) {
 		return nil, fmt.Errorf("the CRL would go stale (%s) before it is issued (%s)",
@@ -70,7 +66,7 @@ 			ReasonCode:     opts.Reason,
 		}},
 	}
 	// Ed25519 signing reads no randomness, so rand is never used.
-	der, err := x509.CreateRevocationList(rand.Reader, tmpl, issuer, key)
+	der, err := x509.CreateRevocationList(rand.Reader, tmpl, anchor, key)
 	if err != nil {
 		return nil, err
 	}
diff --git a/lisp2gov/repeal_test.go b/lisp2gov/repeal_test.go
index 6bde2ea0bb62c3ddd6920e301aa24081c105b621..585d8085b2cee8b91fd367d457841c88ce203b27 100644
--- a/lisp2gov/repeal_test.go
+++ b/lisp2gov/repeal_test.go
@@ -26,37 +26,29 @@ 	}
 	return crl
 }
 
-func TestRepealEachDepth(t *testing.T) {
+func TestRepeal(t *testing.T) {
 	out, err := Compile("(+ 1 (* 2 3))", Options{})
 	if err != nil {
 		t.Fatal(err)
 	}
 	certs := parsePEM(t, out)
-	for depth := 1; depth < len(certs); depth++ {
-		data, err := Repeal(certs, depth, RepealOptions{Reason: 4, At: issued, Issued: issued, NextUpdate: never})
-		if err != nil {
-			t.Fatalf("depth %d: %v", depth, err)
-		}
-		crl := parseCRL(t, data)
-		// The issuer of the repealed cert signs the CRL, not the anchor.
-		if err := crl.CheckSignatureFrom(certs[depth-1]); err != nil {
-			t.Errorf("depth %d: CRL does not verify against its issuer: %v", depth, err)
-		}
-		if depth > 1 {
-			if err := crl.CheckSignatureFrom(certs[0]); err == nil {
-				t.Errorf("depth %d: CRL verifies against the anchor too", depth)
-			}
-		}
-		if len(crl.RevokedCertificateEntries) != 1 {
-			t.Fatalf("depth %d: %d entries", depth, len(crl.RevokedCertificateEntries))
-		}
-		e := crl.RevokedCertificateEntries[0]
-		if e.SerialNumber.Cmp(certs[depth].SerialNumber) != 0 || e.ReasonCode != 4 || !e.RevocationTime.Equal(issued) {
-			t.Errorf("depth %d: entry serial %v reason %d time %v", depth, e.SerialNumber, e.ReasonCode, e.RevocationTime)
-		}
-		if !crl.ThisUpdate.Equal(issued) || !crl.NextUpdate.Equal(never) {
-			t.Errorf("depth %d: thisUpdate %v nextUpdate %v", depth, crl.ThisUpdate, crl.NextUpdate)
-		}
+	data, err := Repeal(certs, RepealOptions{Reason: 4, At: issued, Issued: issued, NextUpdate: never})
+	if err != nil {
+		t.Fatal(err)
+	}
+	crl := parseCRL(t, data)
+	if err := crl.CheckSignatureFrom(certs[0]); err != nil {
+		t.Errorf("CRL does not verify against the anchor: %v", err)
+	}
+	if len(crl.RevokedCertificateEntries) != 1 {
+		t.Fatalf("%d entries", len(crl.RevokedCertificateEntries))
+	}
+	e := crl.RevokedCertificateEntries[0]
+	if e.SerialNumber.Cmp(certs[1].SerialNumber) != 0 || e.ReasonCode != 4 || !e.RevocationTime.Equal(issued) {
+		t.Errorf("entry serial %v reason %d time %v", e.SerialNumber, e.ReasonCode, e.RevocationTime)
+	}
+	if !crl.ThisUpdate.Equal(issued) || !crl.NextUpdate.Equal(never) {
+		t.Errorf("thisUpdate %v nextUpdate %v", crl.ThisUpdate, crl.NextUpdate)
 	}
 }
 
@@ -64,8 +56,8 @@ func TestRepealIsDeterministic(t *testing.T) {
 	out, _ := Compile("(+ 1 2)", Options{})
 	certs := parsePEM(t, out)
 	opts := RepealOptions{At: issued, Issued: issued, NextUpdate: never}
-	a, _ := Repeal(certs, 2, opts)
-	b, _ := Repeal(certs, 2, opts)
+	a, _ := Repeal(certs, opts)
+	b, _ := Repeal(certs, opts)
 	if string(a) != string(b) {
 		t.Error("two repeals with the same inputs differ")
 	}
@@ -78,17 +70,16 @@ 	other := [32]byte{4}
 	ok := RepealOptions{At: issued, Issued: issued, NextUpdate: never}
 	tests := []struct {
 		name  string
-		depth int
+		certs []*x509.Certificate
 		opts  RepealOptions
 		want  string
 	}{
-		{"depth 0 is the anchor", 0, ok, "depths 1 to 2"},
-		{"depth past the bottom", 3, ok, "depths 1 to 2"},
-		{"someone else's key", 1, RepealOptions{Seed: &other, At: issued, Issued: issued, NextUpdate: never}, "did not compile"},
-		{"stale before it is issued", 1, RepealOptions{At: issued, Issued: issued, NextUpdate: issued}, "go stale"},
+		{"only an anchor", certs[:1], ok, "at least 2 certs"},
+		{"someone else's key", certs, RepealOptions{Seed: &other, At: issued, Issued: issued, NextUpdate: never}, "did not compile"},
+		{"stale before it is issued", certs, RepealOptions{At: issued, Issued: issued, NextUpdate: issued}, "go stale"},
 	}
 	for _, tt := range tests {
-		_, err := Repeal(certs, tt.depth, tt.opts)
+		_, err := Repeal(tt.certs, tt.opts)
 		if err == nil || !strings.Contains(err.Error(), tt.want) {
 			t.Errorf("%s: %v, want %q", tt.name, err, tt.want)
 		}
diff --git a/ratify/repeal_test.go b/ratify/repeal_test.go
index 1f4f3a58599c15c1d5b7ec83c1339bbeafa52c57..369c29efa23dacda848cd77a8f51c7ef33507aef 100644
--- a/ratify/repeal_test.go
+++ b/ratify/repeal_test.go
@@ -3,9 +3,11 @@
 import (
 	"crypto/ed25519"
 	"crypto/rand"
+	"crypto/sha256"
 	"crypto/x509"
 	"encoding/pem"
 	"math/big"
+	"strconv"
 	"testing"
 	"time"
 
@@ -38,13 +40,45 @@ 	}
 	return data, certs
 }
 
+// repealOf repeals the cert at depth, signed by its issuer. lisp2gov only
+// ever repeals depth 1, but a CRL from any cert of the chain is a valid
+// repeal, so these are made by hand with the same key derivation.
 func repealOf(t *testing.T, certs []*x509.Certificate, depth int, seed *[32]byte, at, next time.Time) []byte {
 	t.Helper()
-	crl, err := lisp2gov.Repeal(certs, depth, lisp2gov.RepealOptions{Seed: seed, Reason: Reasons["superseded"], At: at, Issued: feb, NextUpdate: next})
+	s := lisp2gov.DefaultSeed
+	if seed != nil {
+		s = *seed
+	}
+	key := ed25519.NewKeyFromSeed(s[:])
+	if depth > 1 {
+		h := sha256.Sum256([]byte(string(s[:]) + "GOVERNMENT" + strconv.Itoa(depth-1)))
+		key = ed25519.NewKeyFromSeed(h[:])
+	}
+	der, err := x509.CreateRevocationList(rand.Reader, &x509.RevocationList{
+		Number: big.NewInt(feb.Unix()), ThisUpdate: feb, NextUpdate: next,
+		RevokedCertificateEntries: []x509.RevocationListEntry{{
+			SerialNumber: certs[depth].SerialNumber, RevocationTime: at, ReasonCode: Reasons["superseded"],
+		}},
+	}, certs[depth-1], key)
 	if err != nil {
 		t.Fatal(err)
 	}
-	return crl
+	return pem.EncodeToMemory(&pem.Block{Type: "X509 CRL", Bytes: der})
+}
+
+// TestRepealsFromTheCompiler checks the CRLs lisp2gov writes, not just
+// hand-made ones.
+func TestRepealsFromTheCompiler(t *testing.T) {
+	_, certs := program(t, "p", nil)
+	crl, err := lisp2gov.Repeal(certs, lisp2gov.RepealOptions{Reason: Reasons["superseded"], At: mar, Issued: feb, NextUpdate: ever})
+	if err != nil {
+		t.Fatal(err)
+	}
+	crls, err := LoadCRLs(crl)
+	if err != nil {
+		t.Fatal(err)
+	}
+	checkCode(t, "compiler repeal", CheckRepeals(certs, crls, apr), ErrRepealed, "depth 1 repealed 2027-03-01 (superseded)")
 }
 
 func TestRepeals(t *testing.T) {