@xemahq/xema 0.40.3 → 0.41.0

package/dist/commands/edition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edition.d.ts","sourceRoot":"","sources":["../../src/commands/edition.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyCzC,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiBtD"}
+{"version":3,"file":"edition.d.ts","sourceRoot":"","sources":["../../src/commands/edition.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2CzC,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiBtD"}

package/dist/commands/edition.js

@@ -8,6 +8,7 @@ const VERB_SUMMARY = {
     [verb_map_1.EditionVerb.Resolve]: 'Resolve the whole release lock set of an edition: xema edition resolve <id> [--check]; or a customer edition against the catalogue pinned in catalogue.pin.json beside the definition: xema edition resolve --definition <file> --channel <release|develop> --out <dir> [--source-image <source>=<registry>/<prefix>]...',
     [verb_map_1.EditionVerb.Seal]: 'Seal the image digests of an edition: xema edition seal <id> [--definition <file>] (a customer edition seals against the release catalogue pinned in catalogue.pin.json beside the definition)',
     [verb_map_1.EditionVerb.Develop]: 'Resolve a develop edition snapshot: xema edition develop <resolve|target|freeze-graph|freeze-sources|check-existing|check-overrides> ...; or a customer develop edition (catalogue pinned in catalogue.pin.json beside the definition): xema edition develop <resolve|target|check-existing|freeze-sources> --definition <file> ... (resolve: --pins <file> --out <dir> --registry <root> --engine-image <repo>@sha256:<digest> [--source-image <source>=<registry>/<prefix>]...; target: --pins <file> --registry <root> --engine-image <repo>@sha256:<digest> [--source-image ...]; check-existing: --pins <file> --artifact <dir> --engine-image <repo>@sha256:<digest> [--source-image ...]). The develop tag is sha256 of the CLI version, the engine image, the pins and the source-image map.',
+    [verb_map_1.EditionVerb.Release]: 'Resolve a customer release edition (catalogue pinned for release in catalogue.pin.json beside the definition): xema edition release <freeze-sources|target|check-existing|resolve> --definition <file> ... (freeze-sources: --out <pins.json>, each source at its declared ref; resolve: --pins <file> --out <dir> --registry <root> --engine-image <repo>@sha256:<digest> [--source-image <source>=<registry>/<prefix>]...; target: --pins <file> --registry <root> --engine-image <repo>@sha256:<digest> [--source-image ...]; resolve and check-existing are refused until the release catalogue evidence is verified)',
     [verb_map_1.EditionVerb.Artifact]: 'Write the OCI artifact files of a release edition from the committed sealed locks: xema edition artifact <id> --channel release --registry <root> --coordinate <tag> --engine-image <repo>@sha256:<digest> --out <dir>',
     [verb_map_1.EditionVerb.Catalogue]: 'Write the catalogue.json of a release offering from its committed sealed locks: xema edition catalogue <id> --out <dir>',
     [verb_map_1.EditionVerb.Index]: `Rebuild a catalogue index: xema edition index <${Object.values(verb_map_1.EditionIndexKind).join('|')}> [--check]; xema edition index runtime-image-source --repin-contract-authority --kernel-commit <40-hex> replaces only the contract authority of the committed index with the kernel checkout's at the stated commit (its HEAD must equal it)`,

package/dist/commands/edition.js.map

@@ -1 +1 @@
-{"version":3,"file":"edition.js","sourceRoot":"","sources":["../../src/commands/edition.ts"],"names":[],"mappings":";;AA6CA,0CAiBC;AA9DD,kDAA8D;AAC9D,4DAA8D;AAC9D,0DAA2H;AAW3H,MAAM,YAAY,GAA0C;IAC1D,CAAC,sBAAW,CAAC,OAAO,CAAC,EACnB,0TAA0T;IAC5T,CAAC,sBAAW,CAAC,IAAI,CAAC,EAAE,gMAAgM;IACpN,CAAC,sBAAW,CAAC,OAAO,CAAC,EAAE,swBAAswB;IAC7xB,CAAC,sBAAW,CAAC,QAAQ,CAAC,EACpB,wNAAwN;IAC1N,CAAC,sBAAW,CAAC,SAAS,CAAC,EAAE,yHAAyH;IAClJ,CAAC,sBAAW,CAAC,KAAK,CAAC,EAAE,kDAAkD,MAAM,CAAC,MAAM,CAAC,2BAAgB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,+OAA+O;IAC/V,CAAC,sBAAW,CAAC,KAAK,CAAC,EAAE,oIAAoI;IACzJ,CAAC,sBAAW,CAAC,GAAG,CAAC,EAAE,qEAAqE;IACxF,CAAC,sBAAW,CAAC,eAAe,CAAC,EAAE,qGAAqG;IACpI,CAAC,sBAAW,CAAC,eAAe,CAAC,EAAE,wEAAwE;IACvG,CAAC,sBAAW,CAAC,kBAAkB,CAAC,EAAE,mIAAmI;IACrK,CAAC,sBAAW,CAAC,cAAc,CAAC,EAC1B,yQAAyQ;IAC3Q,CAAC,sBAAW,CAAC,QAAQ,CAAC,EAAE,+EAA+E,MAAM,CAAC,MAAM,CAAC,8BAAmB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK;IACxJ,CAAC,sBAAW,CAAC,IAAI,CAAC,EAAE,6FAA6F;IACjH,CAAC,sBAAW,CAAC,KAAK,CAAC,EAAE,6JAA6J;IAClL,CAAC,sBAAW,CAAC,QAAQ,CAAC,EAAE,gGAAgG,MAAM,CAAC,MAAM,CAAC,mCAAwB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,qKAAqK;IAC9U,CAAC,sBAAW,CAAC,cAAc,CAAC,EAC1B,6LAA6L;IAC/L,CAAC,sBAAW,CAAC,MAAM,CAAC,EAClB,yMAAyM;IAC3M,CAAC,sBAAW,CAAC,GAAG,CAAC,EACf,mWAAmW;IACrW,CAAC,sBAAW,CAAC,KAAK,CAAC,EACjB,qMAAqM;IACvM,CAAC,sBAAW,CAAC,aAAa,CAAC,EACzB,uMAAuM;CAC1M,CAAC;AAEF,SAAgB,eAAe,CAAC,OAAgB;IAC9C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,kCAAkC,CAAC,CAAC;IACvF,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,sBAAW,CAAC,EAAE,CAAC;QAC9C,OAAO;aACJ,OAAO,CAAC,IAAI,CAAC;aACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;aAC/B,QAAQ,CAAC,WAAW,EAAE,0DAA0D,CAAC;aACjF,kBAAkB,EAAE;aACpB,MAAM,CAAC,CAAC,IAAc,EAAE,EAAE;YACzB,IAAI,CAAC;gBACH,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAA,0BAAc,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC;gBAChD,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACzB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAA,qBAAQ,EAAC,4BAAe,CAAC,YAAY,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACjG,CAAC;QACH,CAAC,CAAC,CAAC;IACP,CAAC;AACH,CAAC"}
+{"version":3,"file":"edition.js","sourceRoot":"","sources":["../../src/commands/edition.ts"],"names":[],"mappings":";;AA+CA,0CAiBC;AAhED,kDAA8D;AAC9D,4DAA8D;AAC9D,0DAA2H;AAW3H,MAAM,YAAY,GAA0C;IAC1D,CAAC,sBAAW,CAAC,OAAO,CAAC,EACnB,0TAA0T;IAC5T,CAAC,sBAAW,CAAC,IAAI,CAAC,EAAE,gMAAgM;IACpN,CAAC,sBAAW,CAAC,OAAO,CAAC,EAAE,swBAAswB;IAC7xB,CAAC,sBAAW,CAAC,OAAO,CAAC,EACnB,2lBAA2lB;IAC7lB,CAAC,sBAAW,CAAC,QAAQ,CAAC,EACpB,wNAAwN;IAC1N,CAAC,sBAAW,CAAC,SAAS,CAAC,EAAE,yHAAyH;IAClJ,CAAC,sBAAW,CAAC,KAAK,CAAC,EAAE,kDAAkD,MAAM,CAAC,MAAM,CAAC,2BAAgB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,+OAA+O;IAC/V,CAAC,sBAAW,CAAC,KAAK,CAAC,EAAE,oIAAoI;IACzJ,CAAC,sBAAW,CAAC,GAAG,CAAC,EAAE,qEAAqE;IACxF,CAAC,sBAAW,CAAC,eAAe,CAAC,EAAE,qGAAqG;IACpI,CAAC,sBAAW,CAAC,eAAe,CAAC,EAAE,wEAAwE;IACvG,CAAC,sBAAW,CAAC,kBAAkB,CAAC,EAAE,mIAAmI;IACrK,CAAC,sBAAW,CAAC,cAAc,CAAC,EAC1B,yQAAyQ;IAC3Q,CAAC,sBAAW,CAAC,QAAQ,CAAC,EAAE,+EAA+E,MAAM,CAAC,MAAM,CAAC,8BAAmB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK;IACxJ,CAAC,sBAAW,CAAC,IAAI,CAAC,EAAE,6FAA6F;IACjH,CAAC,sBAAW,CAAC,KAAK,CAAC,EAAE,6JAA6J;IAClL,CAAC,sBAAW,CAAC,QAAQ,CAAC,EAAE,gGAAgG,MAAM,CAAC,MAAM,CAAC,mCAAwB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,qKAAqK;IAC9U,CAAC,sBAAW,CAAC,cAAc,CAAC,EAC1B,6LAA6L;IAC/L,CAAC,sBAAW,CAAC,MAAM,CAAC,EAClB,yMAAyM;IAC3M,CAAC,sBAAW,CAAC,GAAG,CAAC,EACf,mWAAmW;IACrW,CAAC,sBAAW,CAAC,KAAK,CAAC,EACjB,qMAAqM;IACvM,CAAC,sBAAW,CAAC,aAAa,CAAC,EACzB,uMAAuM;CAC1M,CAAC;AAEF,SAAgB,eAAe,CAAC,OAAgB;IAC9C,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,kCAAkC,CAAC,CAAC;IACvF,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,sBAAW,CAAC,EAAE,CAAC;QAC9C,OAAO;aACJ,OAAO,CAAC,IAAI,CAAC;aACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;aAC/B,QAAQ,CAAC,WAAW,EAAE,0DAA0D,CAAC;aACjF,kBAAkB,EAAE;aACpB,MAAM,CAAC,CAAC,IAAc,EAAE,EAAE;YACzB,IAAI,CAAC;gBACH,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAA,0BAAc,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC;gBAChD,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACzB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAA,qBAAQ,EAAC,4BAAe,CAAC,YAAY,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACjG,CAAC;QACH,CAAC,CAAC,CAAC;IACP,CAAC;AACH,CAAC"}

package/dist/edition/verify-image-evidence.bundle.mjs

@@ -62184,7 +62184,8 @@ var edition_contract_default = {
     catalogue: "catalogue.json"
   },
   provenancePins: {
-    catalogue: "the sha256 digest (sha256:<64 hex>) of the offering artifact a customer edition was resolved against; every other pin is a 40-hex commit"
+    catalogue: "the sha256 digest (sha256:<64 hex>) of the offering artifact a customer edition was resolved against",
+    definition: "the sha256 digest (sha256:<64 hex>) of the canonical JSON of the customer definition a customer edition was resolved from (vendor selection, image registry mirror, Store publisher anchors, sources); every other pin is a 40-hex commit"
   },
   imageNamespaceSegment: "dev",
   evidenceTrust: {
@@ -62215,6 +62216,11 @@ var CATALOGUE_PIN_KEY = "catalogue";
 if (!(CATALOGUE_PIN_KEY in EDITION_CONTRACT.provenancePins)) {
   throw new Error("edition-contract.json provenancePins does not declare the catalogue pin");
 }
+var DEFINITION_PIN_KEY = "definition";
+if (!(DEFINITION_PIN_KEY in EDITION_CONTRACT.provenancePins)) {
+  throw new Error("edition-contract.json provenancePins does not declare the definition pin");
+}
+var DIGEST_PIN_KEYS = Object.freeze([CATALOGUE_PIN_KEY, DEFINITION_PIN_KEY]);
 var EditionLockFile = Object.freeze({
   Distribution: "distribution.lock.json",
   Images: "images.lock.json",
@@ -63107,7 +63113,7 @@ function assertEngineImage(image) {
   return image;
 }
 var COMMIT_PATTERN2 = /^[0-9a-f]{40}$/;
-var CATALOGUE_DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;
+var DIGEST_PIN_PATTERN = /^sha256:[0-9a-f]{64}$/;
 var exactKeys = (value, keys, where) => {
   if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join() !== [...keys].sort().join()) {
     throw new Error(`${where} must be exactly {${keys.join(", ")}}`);
@@ -63128,13 +63134,14 @@ function parseEditionDescriptor(value) {
   }
   const { pins, workflow } = value.provenance;
   if (pins === null || typeof pins !== "object" || Array.isArray(pins)) {
-    throw new Error(`${EDITION_DESCRIPTOR_FILE}: provenance.pins must map pin keys to 40-hex commits (the "${CATALOGUE_PIN_KEY}" pin to a sha256 digest)`);
+    throw new Error(`${EDITION_DESCRIPTOR_FILE}: provenance.pins must map pin keys to 40-hex commits (the ${DIGEST_PIN_KEYS.map((key) => `"${key}"`).join(" and ")} pins to sha256 digests)`);
   }
   for (const [key, pin] of Object.entries(pins)) {
-    const pattern = key === CATALOGUE_PIN_KEY ? CATALOGUE_DIGEST_PATTERN : COMMIT_PATTERN2;
+    const digestPin = DIGEST_PIN_KEYS.includes(key);
+    const pattern = digestPin ? DIGEST_PIN_PATTERN : COMMIT_PATTERN2;
     if (typeof pin !== "string" || !pattern.test(pin)) {
       throw new Error(
-        key === CATALOGUE_PIN_KEY ? `${EDITION_DESCRIPTOR_FILE}: provenance.pins["${key}"] must be a sha256:<64 hex> digest` : `${EDITION_DESCRIPTOR_FILE}: provenance.pins must map pin keys to 40-hex commits (${JSON.stringify(key)} is not)`
+        digestPin ? `${EDITION_DESCRIPTOR_FILE}: provenance.pins["${key}"] must be a sha256:<64 hex> digest` : `${EDITION_DESCRIPTOR_FILE}: provenance.pins must map pin keys to 40-hex commits (${JSON.stringify(key)} is not)`
       );
     }
   }
@@ -64704,7 +64711,7 @@ var PIN_KEYS = Object.freeze([
 ]);
 var VERIFIER_KEYS = Object.freeze(["bundleDigest", "provenanceDigest"]);
 var AUTHORITY_PIN_KEYS = Object.freeze(["digest", "sourceCommit"]);
-var PIN_SHAPE = "{schemaVersion, policyDigest, verifier: {bundleDigest, provenanceDigest}, kernelContractAuthority: {sourceCommit, digest}, trustedOrasBinaryDigests: [sha256:…, …]}";
+var PIN_SHAPE = "{schemaVersion, policyDigest, verifier: {bundleDigest, provenanceDigest}, kernelContractAuthority: {sourceCommit, digest} | null, trustedOrasBinaryDigests: [sha256:…, …]}";
 var exactKeys2 = (value, keys) => value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).sort().join() === keys.join();
 function requireDigest(value, what) {
   if (typeof value !== "string" || !SHA256_DIGEST.test(value)) {
@@ -64739,7 +64746,7 @@ function readEvidenceTrustPin({ dataRoot: dataRoot2, declaration }) {
     MAX_PIN_BYTES
   );
   const pin = parseStrictJson(bytes.toString("utf8"), declaration.pin);
-  if (!exactKeys2(pin, PIN_KEYS) || !exactKeys2(pin.verifier, VERIFIER_KEYS) || !exactKeys2(pin.kernelContractAuthority, AUTHORITY_PIN_KEYS) || !Array.isArray(pin.trustedOrasBinaryDigests)) {
+  if (!exactKeys2(pin, PIN_KEYS) || !exactKeys2(pin.verifier, VERIFIER_KEYS) || !(pin.kernelContractAuthority === null || exactKeys2(pin.kernelContractAuthority, AUTHORITY_PIN_KEYS)) || !Array.isArray(pin.trustedOrasBinaryDigests)) {
     throw new Error(`${declaration.pin}: the pin is exactly ${PIN_SHAPE}`);
   }
   if (pin.schemaVersion !== EVIDENCE_TRUST_PIN_SCHEMA_VERSION) {
@@ -64757,7 +64764,7 @@ function readEvidenceTrustPin({ dataRoot: dataRoot2, declaration }) {
         "verifier.provenanceDigest"
       )
     }),
-    kernelContractAuthority: Object.freeze({
+    kernelContractAuthority: pin.kernelContractAuthority === null ? null : Object.freeze({
       sourceCommit: requireCommit(pin.kernelContractAuthority.sourceCommit),
       digest: requireDigest(pin.kernelContractAuthority.digest, "kernelContractAuthority.digest")
     }),
@@ -64802,6 +64809,12 @@ function readStatedKernelContractAuthority({ dataRoot: dataRoot2, schemas: schem
 }
 function assertPinnedKernelContractAuthority({ pin, authority, label: label2 }) {
   const actual = kernelContractAuthorityPin(authority);
+  if (pin.kernelContractAuthority === null) {
+    throw new KernelContractAuthorityPinError(
+      KERNEL_CONTRACT_AUTHORITY_NOT_PINNED_ONE,
+      `${label2} states kernel contract authority ${actual.sourceCommit} (${actual.digest}) but the pin records none (it was written for a data root without a runtime image source index); review the index, then re-pin with \`${REPIN_COMMAND}\``
+    );
+  }
   if (actual.sourceCommit !== pin.kernelContractAuthority.sourceCommit || actual.digest !== pin.kernelContractAuthority.digest) {
     throw new KernelContractAuthorityPinError(
       KERNEL_CONTRACT_AUTHORITY_NOT_PINNED_ONE,
@@ -65169,6 +65182,259 @@ async function loadVerifierKernelSchemas() {
   return { schemas, editionProtocol: edition_protocol_default };
 }
 
+// edition/sigstore-bundle-media-type.mjs
+var BUNDLE_MEDIA_TYPE = "application/vnd.dev.sigstore.bundle.v0.3+json";
+
+// edition/trust-policy-arming.mjs
+var TrustPolicyArmingState = Object.freeze({
+  ARMED: "armed",
+  UNARMED: "unarmed",
+  PARTIAL: "partial"
+});
+function assertArmingChannel(schemas2, channel) {
+  if (!schemas2.EVIDENCE_CHANNELS.includes(channel)) {
+    throw new Error(
+      `trust-policy arming is judged for one channel; got ${JSON.stringify(channel)}, expected ${schemas2.EVIDENCE_CHANNELS.join(" | ")}`
+    );
+  }
+}
+function assessTrustPolicyArming(policy, schemas2, channel, { consumesCatalogue = false } = {}) {
+  assertArmingChannel(schemas2, channel);
+  const unmet = [];
+  const stages = [
+    ["image-producer", schemas2.IMAGE_PRODUCER_PREDICATE_TYPE],
+    ["distribution-completeness", schemas2.DISTRIBUTION_IMAGES_PREDICATE_TYPE],
+    ["delivery-entitlement", schemas2.IMAGE_DELIVERY_ENTITLEMENT_PREDICATE_TYPE]
+  ];
+  if (consumesCatalogue) {
+    if (typeof schemas2.EDITION_CATALOGUE_PREDICATE_TYPE !== "string") {
+      unmet.push("this kernel states no edition-catalogue predicate (EDITION_CATALOGUE_PREDICATE_TYPE), so a catalogue consumer cannot be armed against it.");
+    } else {
+      stages.push(["edition-catalogue", schemas2.EDITION_CATALOGUE_PREDICATE_TYPE]);
+    }
+  }
+  const onChannel = policy.policies.filter((candidate) => candidate.channel === channel);
+  const authorized = stages.filter(([, predicateType]) => onChannel.some((candidate) => candidate.predicateTypes.includes(predicateType)));
+  if (policy.policies.length === 0) {
+    unmet.push(
+      'policies[] is empty — no signer identity is authorized, so verifySigstoreEvidenceDescriptor throws "offline trust policy authorizes no signer" for every predicate before reading any bundle.'
+    );
+  } else {
+    for (const [stage, predicateType] of stages.filter((candidate) => !authorized.includes(candidate))) {
+      unmet.push(
+        `no policy authorizes the ${stage} predicate ${predicateType} on channel "${channel}" — that stage of a ${channel} delivery would still throw "authorizes no signer" while the policy reads as armed.`
+      );
+    }
+  }
+  if (policy.trustedCosignBinaryDigests.length === 0) {
+    unmet.push(
+      "trustedCosignBinaryDigests[] is empty — prepareDigestPinnedExecutable tests membership with [].includes(digest), which is false for every cosign binary, so no evidence can be verified on any host."
+    );
+  }
+  if (policy.trustedGitBinaryDigests.length === 0) {
+    unmet.push(
+      "trustedGitBinaryDigests[] is empty — the same membership test rejects every git binary, so no verified release checkout can be established."
+    );
+  }
+  const armed = unmet.length === 0;
+  const bootstrap = policy.policies.length === 0 && policy.trustedCosignBinaryDigests.length === 0 && policy.trustedGitBinaryDigests.length === 0;
+  const anotherChannelOnly = onChannel.length === 0 && policy.policies.length > 0;
+  const state = armed ? TrustPolicyArmingState.ARMED : bootstrap || anotherChannelOnly ? TrustPolicyArmingState.UNARMED : TrustPolicyArmingState.PARTIAL;
+  return { state, armed, unmet };
+}
+
+// edition/verify-catalogue-evidence.mjs
+var CATALOGUE_EVIDENCE_MODE = "catalogue-evidence";
+var CATALOGUE_EVIDENCE_USAGE = "usage: catalogue-evidence arming --channel <release|develop> --data-root <dir> | catalogue-evidence verify --channel <c> --data-root <dir> --evidence-root <abs dir> --statement-digest <sha256:..> --bundle-digest <sha256:..> --workflow-sha <40-hex> --offering-id <id> --subject-digest <sha256:..> --catalogue-layer-digest <sha256:..> --lock-layer-digest <sha256:..> --cosign <abs path>";
+var CATALOGUE_EVIDENCE_STATEMENT_FILE = "statement.json";
+var CATALOGUE_EVIDENCE_BUNDLE_FILE = "bundle.sigstore.json";
+var CATALOGUE_EVIDENCE_UNARMED_CODE = EDITION_CONTRACT.evidenceTrust.refusal.code;
+var CatalogueEvidenceRefusalCode = Object.freeze({
+  SubjectMismatch: "catalogue_evidence_subject_mismatch",
+  OfferingMismatch: "catalogue_evidence_offering_mismatch",
+  LockDigestMismatch: "catalogue_evidence_lock_digest_mismatch"
+});
+var SHA256_DIGEST3 = /^sha256:[a-f0-9]{64}$/;
+var COMMIT = /^[a-f0-9]{40}$/;
+var ARMING_FLAGS = Object.freeze(["--channel"]);
+var VERIFY_FLAGS = Object.freeze([
+  "--channel",
+  "--evidence-root",
+  "--statement-digest",
+  "--bundle-digest",
+  "--workflow-sha",
+  "--offering-id",
+  "--subject-digest",
+  "--catalogue-layer-digest",
+  "--lock-layer-digest",
+  "--cosign"
+]);
+var ABSOLUTE_FLAGS = Object.freeze(["--evidence-root", "--cosign"]);
+var DIGEST_FLAGS = Object.freeze(["--statement-digest", "--bundle-digest", "--subject-digest", "--catalogue-layer-digest", "--lock-layer-digest"]);
+var CatalogueEvidenceUsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CatalogueEvidenceUsageError";
+  }
+};
+var CatalogueEvidenceUnarmedError = class extends Error {
+  constructor(message) {
+    super(`${CATALOGUE_EVIDENCE_UNARMED_CODE}: ${message}`);
+    this.name = "EvidenceTrustRequiredError";
+    this.code = CATALOGUE_EVIDENCE_UNARMED_CODE;
+  }
+};
+var CatalogueEvidenceRefusal = class extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.name = "CatalogueEvidenceRefusal";
+    this.code = code;
+  }
+};
+var hexOf = (digest) => digest.slice("sha256:".length);
+function parseFlags(args, allowed) {
+  const flags = /* @__PURE__ */ new Map();
+  for (let index = 0; index < args.length; index += 2) {
+    const flag = args[index];
+    const value = args[index + 1];
+    if (typeof flag !== "string" || !allowed.includes(flag)) {
+      throw new CatalogueEvidenceUsageError(`unknown or unexpected argument ${JSON.stringify(flag)}`);
+    }
+    if (value === void 0 || value.startsWith("--")) {
+      throw new CatalogueEvidenceUsageError(`${flag} requires a value`);
+    }
+    if (flags.has(flag)) {
+      throw new CatalogueEvidenceUsageError(`${flag} was given twice`);
+    }
+    flags.set(flag, value);
+  }
+  for (const flag of allowed) {
+    if (!flags.has(flag)) {
+      throw new CatalogueEvidenceUsageError(`${flag} is required`);
+    }
+  }
+  for (const flag of ABSOLUTE_FLAGS.filter((candidate) => flags.has(candidate))) {
+    if (!flags.get(flag).startsWith("/")) {
+      throw new CatalogueEvidenceUsageError(`${flag} must be an absolute path`);
+    }
+  }
+  for (const flag of DIGEST_FLAGS.filter((candidate) => flags.has(candidate))) {
+    if (!SHA256_DIGEST3.test(flags.get(flag))) {
+      throw new CatalogueEvidenceUsageError(`${flag} must be sha256:<64 lowercase hex>`);
+    }
+  }
+  if (flags.has("--workflow-sha") && !COMMIT.test(flags.get("--workflow-sha"))) {
+    throw new CatalogueEvidenceUsageError("--workflow-sha must be a 40-character lowercase hexadecimal git commit SHA");
+  }
+  return flags;
+}
+async function armedAnchors({ channel, env, bundlePath }) {
+  assertSanitizedOperatorEnvironment(env);
+  const running = readRunningVerifier(bundlePath);
+  const { schemas: schemas2 } = await loadVerifierKernelSchemas();
+  resetEditionWorkspaceConfig();
+  const declaration = editionWorkspaceConfig().evidenceTrustPolicy;
+  if (declaration.policy === null) {
+    throw new CatalogueEvidenceUnarmedError(`${dataRoot()} declares no evidenceTrustPolicy in edition-workspace.json`);
+  }
+  const { policy, policyDigest } = loadDeclaredTrustPolicy({ dataRoot: dataRoot(), declaration, schemas: schemas2 });
+  const pin = readEvidenceTrustPin({ dataRoot: dataRoot(), declaration });
+  assertPinnedPolicy({ pin, policyDigest });
+  assertPinnedVerifier({ pin, actual: verifierDigests(running) });
+  const { state, unmet } = assessTrustPolicyArming(policy, schemas2, channel, { consumesCatalogue: true });
+  if (state !== TrustPolicyArmingState.ARMED) {
+    throw new CatalogueEvidenceUnarmedError(
+      `the declared policy is ${state.toUpperCase()} on the ${channel} channel for a catalogue consumer: ${unmet.join("; ")}`
+    );
+  }
+  return { schemas: schemas2, policy };
+}
+async function runCatalogueEvidence({ argv, env, bundlePath }) {
+  const [mode, phase, ...tail] = argv;
+  if (mode !== CATALOGUE_EVIDENCE_MODE || phase !== "arming" && phase !== "verify") {
+    throw new CatalogueEvidenceUsageError(CATALOGUE_EVIDENCE_USAGE);
+  }
+  let rest;
+  try {
+    rest = configureEditionWorkspaceFromArgv(tail, [WorkspaceRoot.Data], { refuseOthers: true });
+  } catch (error) {
+    throw new CatalogueEvidenceUsageError(error.message);
+  }
+  const flags = parseFlags(rest, phase === "arming" ? ARMING_FLAGS : VERIFY_FLAGS);
+  const channel = flags.get("--channel");
+  const { schemas: schemas2, policy } = await armedAnchors({ channel, env, bundlePath });
+  if (phase === "arming") {
+    return `${JSON.stringify({ channel, state: TrustPolicyArmingState.ARMED })}
+`;
+  }
+  const offeringId = flags.get("--offering-id");
+  const descriptor = {
+    statementPath: CATALOGUE_EVIDENCE_STATEMENT_FILE,
+    statementDigest: flags.get("--statement-digest"),
+    bundlePath: CATALOGUE_EVIDENCE_BUNDLE_FILE,
+    bundleDigest: flags.get("--bundle-digest"),
+    bundleMediaType: BUNDLE_MEDIA_TYPE
+  };
+  const trustedCosign = prepareTrustedCosignBinary({ cosignBinary: flags.get("--cosign"), policy });
+  let statement;
+  try {
+    ({ statement } = verifySigstoreEvidenceDescriptor({
+      evidenceRoot: flags.get("--evidence-root"),
+      descriptor,
+      policy,
+      predicateType: schemas2.EDITION_CATALOGUE_PREDICATE_TYPE,
+      channel,
+      expectedWorkflowSha: flags.get("--workflow-sha"),
+      parseStatement: schemas2.parseEditionCatalogueStatement,
+      policyRoot: dataRoot(),
+      trustedCosign
+    }));
+  } finally {
+    trustedCosign.dispose();
+  }
+  const [subject] = statement.subject;
+  const expectedSubject = `xema-edition-${offeringId}`;
+  if (subject.digest.sha256 !== hexOf(flags.get("--subject-digest")) || subject.name !== expectedSubject) {
+    throw new CatalogueEvidenceRefusal(
+      CatalogueEvidenceRefusalCode.SubjectMismatch,
+      `the statement is over ${subject.name}@sha256:${subject.digest.sha256}, not ${expectedSubject}@${flags.get("--subject-digest")}`
+    );
+  }
+  const refusal = schemas2.editionCatalogueRefusal(statement.predicate, {
+    channel,
+    catalogueLayerDigest: flags.get("--catalogue-layer-digest")
+  });
+  if (refusal !== void 0) {
+    throw new CatalogueEvidenceRefusal(
+      refusal,
+      `the statement states channel ${statement.predicate.channel} and catalogue ${statement.predicate.catalogueDigest}; this catalogue is on ${channel} with layer ${flags.get("--catalogue-layer-digest")}`
+    );
+  }
+  if (statement.predicate.offeringId !== offeringId) {
+    throw new CatalogueEvidenceRefusal(
+      CatalogueEvidenceRefusalCode.OfferingMismatch,
+      `the statement is for offering ${statement.predicate.offeringId}, not ${offeringId}`
+    );
+  }
+  if (statement.predicate.lockDigest !== hexOf(flags.get("--lock-layer-digest"))) {
+    throw new CatalogueEvidenceRefusal(
+      CatalogueEvidenceRefusalCode.LockDigestMismatch,
+      `the statement states lock digest ${statement.predicate.lockDigest}, not that of the lock layer ${flags.get("--lock-layer-digest")}`
+    );
+  }
+  return `${JSON.stringify({ verified: true, offeringId, channel, statementDigest: descriptor.statementDigest })}
+`;
+}
+async function runCatalogueEvidenceEntry({ argv, env, bundlePath }) {
+  try {
+    process.stdout.write(await runCatalogueEvidence({ argv, env, bundlePath }));
+  } catch (error) {
+    process.stderr.write(`catalogue-evidence: ${error.name}: ${error.message}
+`);
+    process.exitCode = error instanceof CatalogueEvidenceUsageError ? 2 : 1;
+  }
+}
+
 // edition/verify-image-evidence.mjs
 var USAGE = "usage: verify-image-evidence <distributionId> --evidence-root <dir> --descriptor <absolute-path> --state <absolute-path> --cosign <absolute-path> --git <absolute-path> [--evidence-set <relative-path>] [--json] [--entitlement <relative-path> --entitlement-workflow-sha <40-hex git sha> --customer <id> --mode <mode> [--target-registry <registry>]] --data-root <dir> --editions-root <dir> --kernel <dir>";
 var EVIDENCE_CHANNEL_OF_EDITION_CHANNEL = Object.freeze({
@@ -65512,7 +65778,13 @@ edition read from ${editionsRoot()} at editions checkout commit ${releaseSourceC
     trustedGit.dispose();
   }
 }
-if (isEntryModule(import.meta.url)) {
+if (isEntryModule(import.meta.url) && process.argv[2] === CATALOGUE_EVIDENCE_MODE) {
+  await runCatalogueEvidenceEntry({
+    argv: process.argv.slice(2),
+    env: process.env,
+    bundlePath: process.argv[1]
+  });
+} else if (isEntryModule(import.meta.url)) {
   await verifyEvidence({
     argv: process.argv.slice(2),
     env: process.env,