feat(v2.8.1): wire canonicalization_profile across the 4 SDKs + close spec gaps

lktron00 · lktron00 · commit 2542cc785b43 · 2026-04-26T22:02:39.000-04:00
v2.8.0 declared the `canonicalization_profile` field in the bundle
manifest schema and described it normatively, but no SDK actually
wrote or read the field — the typed `BundleManifest` structures
shipped without it, and verifiers ignored it. v2.8.1 closes the gap
end to end.

SDK changes (TS / Python / Go / Rust)
-------------------------------------

- TypeScript (`@dcp-ai/sdk` 2.1.0 → 2.1.1): `BundleManifest`
  interface in `types/v2.ts` gains
  `canonicalization_profile?: 'dcp-jcs-v1'`. `BundleBuilderV2.build()`
  in `bundle/builder-v2.ts` emits the field on every produced
  manifest. `verifyV2Bundle` in `core/verify-v2.ts` accepts an absent
  field (assumes `dcp-jcs-v1`), accepts `"dcp-jcs-v1"` explicitly,
  and rejects any other value.

- Python (`dcp-ai` 2.8.0 → 2.8.1): `BundleManifest` in
  `dcp_ai/v2/models.py` gains
  `canonicalization_profile: Literal["dcp-jcs-v1"] | None = "dcp-jcs-v1"`.
  Pydantic enforces unknown-value rejection at parse time; absence
  triggers the default value.

- Go (`sdks/go/v2.8.0` → `v2.8.1`): `BundleManifest` struct in
  `dcp/v2/types.go` gains `CanonicalizationProfile string` with
  `json:"canonicalization_profile,omitempty"`. `BuildBundleV2` in
  `dcp/v2/bundle_builder.go` sets `"dcp-jcs-v1"` on every produced
  manifest. `VerifySignedBundleV2` in `dcp/v2/verify_bundle.go`
  rejects manifests carrying any other value.

- Rust (`dcp-ai` crates.io 2.8.0 → 2.8.1): `BundleManifest` in
  `src/v2/types.rs` gains `pub canonicalization_profile: Option&lt;String&gt;`
  with `skip_serializing_if = "Option::is_none"`. `wasm_build_bundle`
  in `src/lib.rs` emits the field on its manifest.

Spec &amp; profile document
-----------------------

- `spec/DCP-AI-v2.0.md` § 9 (Bundle Manifest) now lists
  `canonicalization_profile` alongside the other manifest fields,
  with an inline note that an absent field MUST be assumed equivalent
  to `"dcp-jcs-v1"`.

- `spec/CANONICALIZATION_PROFILE.md` § 2 — Rule 6 is rewritten as a
  cross-language table that explicitly maps TypeScript, Python, Go,
  and Rust host values onto the JSON wire format for both object
  slots and array slots. The previous prose-only rule left
  Python `None`, Go `nil`, and Rust `Option::None` underspecified
  for verifiers cross-checking foreign producers.

- `spec/CANONICALIZATION_PROFILE.md` § 2 — new Rule 9 makes Unicode
  normalization (NFC, NFD, NFKC, NFKD) explicitly out of scope: the
  canonicalizer emits strings byte-for-byte as the host parser
  delivers them, and a future profile (`dcp-jcs-v2` or later) MAY
  pin a normalization form. RFC 8259 § 8.1 is referenced as the
  conventional choice (NFC) for application-layer normalisation.

- Rule 9 also pins the rationale for not shipping `NaN` /
  `±Infinity` interop fixtures: those values are not part of RFC
  8259 wire format, so most parsers reject them before the
  canonicalizer is reached. Rejection is verified by per-SDK unit
  tests rather than shared fixtures.

Behavioural compatibility
-------------------------

The new field is additive and optional in serialization. A
`v2.8.1`-produced bundle carries `canonicalization_profile:
"dcp-jcs-v1"` on its manifest. Bundles produced by `v2.8.0` or
earlier have no such field, and `v2.8.1` verifiers accept them per
`spec/CANONICALIZATION_PROFILE.md` § 4 (absent ≡ `dcp-jcs-v1`). A
bundle that carries an unknown value (e.g. `"dcp-jcs-v2"`) is
rejected by every `v2.8.1` SDK — the forward-compatibility hook for
future profiles.

The bundle-level signature covers `canonical(manifest)`, so newly-
produced bundles have a different manifest hash than they would
under `v2.8.0`. Existing signed bundles and their stored signatures
remain valid under `v2.8.1` verifiers.

Tests
-----

- Conformance (root): DCP-AI CONFORMANCE PASS (V1 + V2)
- TypeScript: 461/461
- Python: 236/236
- Go: 4 packages OK
- Rust: 181 tests across 10 binaries
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,100 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [2.8.1] - 2026-04-26
+
+### Wired the `canonicalization_profile` field across the four SDKs
+
+`v2.8.0` declared the `canonicalization_profile` field in
+`schemas/v2/bundle_manifest.schema.json` and described it in
+`spec/CANONICALIZATION_PROFILE.md` § 4, but no SDK actually wrote or
+read the field — the typed `BundleManifest` structures shipped without
+it, and verifiers ignored it. `v2.8.1` closes that gap end-to-end.
+
+- **TypeScript (`@dcp-ai/sdk` 2.1.0 → 2.1.1)** — `BundleManifest`
+  interface in `sdks/typescript/src/types/v2.ts` gains
+  `canonicalization_profile?: 'dcp-jcs-v1'`. `BundleBuilderV2.build()`
+  in `sdks/typescript/src/bundle/builder-v2.ts` now emits
+  `canonicalization_profile: "dcp-jcs-v1"` on every produced manifest.
+  `verifyV2Bundle` in `sdks/typescript/src/core/verify-v2.ts` accepts
+  an absent field (assumes `dcp-jcs-v1`), accepts `"dcp-jcs-v1"`
+  explicitly, and rejects any other value with
+  `"Unknown canonicalization_profile: <value>"`.
+- **Python (`dcp-ai` 2.8.0 → 2.8.1)** — `BundleManifest` in
+  `sdks/python/dcp_ai/v2/models.py` gains
+  `canonicalization_profile: Literal["dcp-jcs-v1"] | None = "dcp-jcs-v1"`.
+  Pydantic enforces unknown-value rejection at parse time; absence
+  triggers the default value. No separate verifier change is needed
+  because validation lives in the model.
+- **Go (`sdks/go/v2.8.0` → `v2.8.1`)** — `BundleManifest` struct in
+  `sdks/go/dcp/v2/types.go` gains `CanonicalizationProfile string` with
+  `json:"canonicalization_profile,omitempty"`. `BuildBundleV2` in
+  `sdks/go/dcp/v2/bundle_builder.go` sets it to `"dcp-jcs-v1"` on every
+  produced manifest. `VerifySignedBundleV2` in
+  `sdks/go/dcp/v2/verify_bundle.go` now rejects bundles whose manifest
+  carries a `canonicalization_profile` value other than `"dcp-jcs-v1"`.
+- **Rust (`dcp-ai` crates.io 2.8.0 → 2.8.1)** —
+  `BundleManifest` in `sdks/rust/src/v2/types.rs` gains
+  `pub canonicalization_profile: Option<String>` with
+  `#[serde(skip_serializing_if = "Option::is_none")]`. `wasm_build_bundle`
+  in `sdks/rust/src/lib.rs` sets `"canonicalization_profile":
+  "dcp-jcs-v1"` on the manifest it emits.
+
+### Spec & profile document
+
+- `spec/DCP-AI-v2.0.md` § 9 (Bundle Manifest) now lists
+  `canonicalization_profile` alongside the other manifest fields, with
+  an inline note that an absent field MUST be assumed equivalent to
+  `"dcp-jcs-v1"`.
+- `spec/CANONICALIZATION_PROFILE.md` § 2 — Rule 6 (undefined / null
+  handling) is rewritten as a cross-language table that explicitly
+  lists how TypeScript, Python, Go, and Rust host values map onto the
+  JSON wire format for both object slots and array slots.
+- `spec/CANONICALIZATION_PROFILE.md` § 2 — new Rule 9 makes Unicode
+  normalization (NFC, NFD, NFKC, NFKD) explicitly out of scope: the
+  canonicalizer emits strings byte-for-byte as the host parser
+  delivers them, and a future profile (`dcp-jcs-v2` or later) MAY pin
+  a normalization form. RFC 8259 § 8.1 is referenced as the
+  conventional choice (NFC) for application-layer normalisation.
+- `spec/CANONICALIZATION_PROFILE.md` Rule 9 also pins the rationale
+  for not shipping `NaN` / `±Infinity` interop fixtures: those values
+  are not part of RFC 8259 wire format, so most parsers reject them
+  before the canonicalizer is reached. Rejection is verified by
+  per-SDK unit tests rather than shared fixtures.
+
+### Behavioural compatibility
+
+The new field is **additive and optional in serialization**:
+
+- A `v2.8.1`-produced bundle carries `canonicalization_profile:
+  "dcp-jcs-v1"` on its manifest. Older verifiers that don't know about
+  the field will treat it as an unknown property — which is fine
+  because the JSON Schema declares the field as `additionalProperties`-
+  compatible (it lives among `properties` and is `optional`).
+- A bundle produced by `v2.8.0` or earlier has no
+  `canonicalization_profile` field. `v2.8.1` verifiers accept it: per
+  `spec/CANONICALIZATION_PROFILE.md` § 4, an absent field MUST be
+  assumed equivalent to `"dcp-jcs-v1"`.
+- A bundle that carries `canonicalization_profile` with an unknown
+  value (e.g. `"dcp-jcs-v2"`) is rejected by every `v2.8.1` SDK. This
+  is the forward-compatibility hook for future profiles: a verifier
+  that hasn't been updated to a new profile MUST refuse it rather than
+  silently accept a manifest it cannot validate.
+
+The bundle-level signature covers `canonical(manifest)`, so adding the
+field changes the manifest hash of any newly-produced bundle relative
+to one that would have been produced under `v2.8.0`. Bundles produced
+under `v2.8.0` and earlier, and their stored signatures, remain valid
+under `v2.8.1` verifiers.
+
+### Versions bumped
+
+- `dcp-ai` (PyPI) 2.8.0 → 2.8.1
+- `dcp-ai` (crates.io) 2.8.0 → 2.8.1
+- `github.com/dcp-ai-protocol/dcp-ai/sdks/go/v2` v2.8.0 → v2.8.1
+- `@dcp-ai/sdk` (npm) 2.1.0 → 2.1.1 — first TypeScript code change
+  since 2.1.0 (the 2.8.0 release was a docstring-only edit)
+
 ## [2.8.0] - 2026-04-26
 
 ### Added — Canonicalization profile `dcp-jcs-v1`
diff --git a/sdks/go/dcp/observability/telemetry.go b/sdks/go/dcp/observability/telemetry.go
@@ -24,7 +24,7 @@ import (
 
 // SDKVersion is reported to OpenTelemetry as `service.version`. Bumped in
 // lockstep with the Go module tag under sdks/go/v*.
-const SDKVersion = "2.8.0"
+const SDKVersion = "2.8.1"
 
 // ExporterType selects how events are forwarded outside the in-memory bus.
 type ExporterType string
diff --git a/sdks/go/dcp/v2/bundle_builder.go b/sdks/go/dcp/v2/bundle_builder.go
@@ -82,6 +82,7 @@ func BuildBundleV2(input BundleBuildInput) (*CitizenshipBundleV2, error) {
 		AuditMerkleRoot:          "sha256:" + auditMerkleSHA256,
 		AuditMerkleRootSecondary: "sha3-256:" + auditMerkleSHA3,
 		AuditCount:               len(input.AuditEntries),
+		CanonicalizationProfile:  "dcp-jcs-v1",
 	}
 
 	bundle := &CitizenshipBundleV2{
diff --git a/sdks/go/dcp/v2/types.go b/sdks/go/dcp/v2/types.go
@@ -143,6 +143,12 @@ type BundleManifest struct {
 	AuditMerkleRootSecondary string   `json:"audit_merkle_root_secondary,omitempty"`
 	AuditCount               int      `json:"audit_count"`
 	PQCheckpoints            []string `json:"pq_checkpoints,omitempty"`
+	// CanonicalizationProfile identifies the JSON canonicalization profile
+	// under which this bundle was produced. Optional today (only "dcp-jcs-v1"
+	// is defined; absence is assumed equivalent to "dcp-jcs-v1" — see
+	// spec/CANONICALIZATION_PROFILE.md § 4). Future profiles will make the
+	// field required.
+	CanonicalizationProfile string `json:"canonicalization_profile,omitempty"`
 }
 
 // BundleSignerV2 describes who signed a V2 bundle.
diff --git a/sdks/go/dcp/v2/verify_bundle.go b/sdks/go/dcp/v2/verify_bundle.go
@@ -67,6 +67,14 @@ func VerifySignedBundleV2(registry *AlgorithmRegistry, signedBundleJSON []byte)
 	}
 	result.SessionBindingValid = manifestNonce != ""
 
+	// Per spec/CANONICALIZATION_PROFILE.md § 4: a missing canonicalization_profile
+	// MUST be assumed equal to the only profile defined today, "dcp-jcs-v1".
+	// An unknown value is rejected; future profiles will register their own
+	// canonicalizer here.
+	if profile, ok := manifest["canonicalization_profile"].(string); ok && profile != "dcp-jcs-v1" {
+		result.Errors = append(result.Errors, fmt.Sprintf("Unknown canonicalization_profile: %s", profile))
+	}
+
 	verifyManifestHashes(bundle, manifest, result)
 	verifySessionNonceConsistency(bundle, manifestNonce, result)
 	verifyBundleSignature(registry, bundle, signature, manifest, result)
diff --git a/sdks/python/dcp_ai/v2/models.py b/sdks/python/dcp_ai/v2/models.py
@@ -134,6 +134,11 @@ class BundleManifest(BaseModel):
     audit_merkle_root_secondary: str | None = None
     audit_count: int
     pq_checkpoints: list[PQCheckpoint] | None = None
+    # Per spec/CANONICALIZATION_PROFILE.md § 4: optional today, only
+    # "dcp-jcs-v1" is defined. Pydantic Literal enforces unknown-value
+    # rejection at parse time. A bundle without the field is accepted
+    # and the default below makes any new manifest emit it.
+    canonicalization_profile: Literal["dcp-jcs-v1"] | None = "dcp-jcs-v1"
 
 
 # ── Capabilities & Verifier Policy ──
diff --git a/sdks/python/pyproject.toml b/sdks/python/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dcp-ai"
-version = "2.8.0"
+version = "2.8.1"
 description = "Python SDK for the Digital Citizenship Protocol for AI Agents"
 readme = "README.md"
 license = "Apache-2.0"
diff --git a/sdks/rust/Cargo.lock b/sdks/rust/Cargo.lock
diff --git a/sdks/rust/Cargo.toml b/sdks/rust/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "dcp-ai"
-version = "2.8.0"
+version = "2.8.1"
 edition = "2021"
 description = "Rust SDK for the Digital Citizenship Protocol for AI Agents"
 license = "Apache-2.0"
diff --git a/sdks/rust/src/lib.rs b/sdks/rust/src/lib.rs
@@ -830,7 +830,8 @@ pub mod wasm {
             "policy_hash": policy_hash,
             "audit_merkle_root": audit_merkle_sha256,
             "audit_merkle_root_secondary": audit_merkle_sha3,
-            "audit_count": audit_entries.len()
+            "audit_count": audit_entries.len(),
+            "canonicalization_profile": "dcp-jcs-v1"
         });
 
         let bundle = json!({
diff --git a/sdks/rust/src/v2/types.rs b/sdks/rust/src/v2/types.rs
@@ -175,6 +175,13 @@ pub struct BundleManifest {
     pub audit_count: u32,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub pq_checkpoints: Option<Vec<String>>,
+    /// JSON canonicalization profile under which this bundle was produced.
+    /// Optional today (only `"dcp-jcs-v1"` is defined; absence is assumed
+    /// equivalent to `"dcp-jcs-v1"` per
+    /// `spec/CANONICALIZATION_PROFILE.md` § 4). Future profiles will make
+    /// the field required.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub canonicalization_profile: Option<String>,
 }
 
 // ── Capability Discovery ──
diff --git a/sdks/typescript/package.json b/sdks/typescript/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@dcp-ai/sdk",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "TypeScript SDK for the Digital Citizenship Protocol for AI Agents",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -15,7 +15,7 @@
   },
   "files": ["dist"],
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts --clean --define.__DCP_SDK_VERSION__=\\\"2.1.0\\\"",
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean --define.__DCP_SDK_VERSION__=\\\"2.1.1\\\"",
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "tsc --noEmit",
diff --git a/sdks/typescript/src/bundle/builder-v2.ts b/sdks/typescript/src/bundle/builder-v2.ts
@@ -193,6 +193,7 @@ export class BundleBuilderV2 {
       policy_hash: policyHash,
       audit_merkle_root: `sha256:${sha256Root}`,
       audit_count: this._auditEntries.length,
+      canonicalization_profile: 'dcp-jcs-v1',
     };
 
     if (this._dualHash) {
diff --git a/sdks/typescript/src/core/verify-v2.ts b/sdks/typescript/src/core/verify-v2.ts
@@ -255,6 +255,15 @@ export async function verifySignedBundleV2(
 
   // ── 4. Manifest integrity ──
 
+  // Canonicalization profile: per spec/CANONICALIZATION_PROFILE.md § 4,
+  // a missing field defaults to 'dcp-jcs-v1' (the only profile defined
+  // today). An unknown value is rejected; a future profile (dcp-jcs-v2)
+  // will register its own canonicalizer here.
+  const profile = bundle.manifest.canonicalization_profile;
+  if (profile !== undefined && profile !== 'dcp-jcs-v1') {
+    errors.push(`Unknown canonicalization_profile: ${profile}`);
+  }
+
   const expectedRprHash = `sha256:${payloadHashHex(bundle.responsible_principal_record.payload)}`;
   const expectedPassportHash = `sha256:${payloadHashHex(bundle.agent_passport.payload)}`;
   const expectedIntentHash = `sha256:${payloadHashHex(bundle.intent.payload)}`;
diff --git a/sdks/typescript/src/types/v2.ts b/sdks/typescript/src/types/v2.ts
@@ -176,6 +176,7 @@ export interface BundleManifest {
   pq_checkpoints?: string[];
   session_expires_at?: string;
   intended_verifier?: string;
+  canonicalization_profile?: 'dcp-jcs-v1';
 }
 
 export interface BundleSignerV2 {
diff --git a/spec/CANONICALIZATION_PROFILE.md b/spec/CANONICALIZATION_PROFILE.md
@@ -111,31 +111,45 @@ input    → [1, null, 3]
 output   → [1,null,3]
 ```
 
-### Rule 6 — Undefined handling (TypeScript-specific)
+### Rule 6 — Null and undefined handling (cross-language)
 
+JSON has one absent-value channel (`null`). Host languages have more.
 TypeScript is the only host language that distinguishes `undefined`
-from `null`. The canonicalizer MUST:
-
-- **In objects**: omit the key entirely when its value is `undefined`.
-- **In arrays**: serialize `undefined` as the literal `null`.
+from `null`; Python, Go, and Rust do not. The canonicalizer MUST treat
+each host value as follows:
+
+| Host language | Host value                                          | In an object key | In an array slot |
+|---------------|-----------------------------------------------------|------------------|------------------|
+| TypeScript    | `undefined`                                         | **omit the key** | emit `null`      |
+| TypeScript    | `null`                                              | emit `null`      | emit `null`      |
+| Python        | absent key                                          | **omit the key** | n/a              |
+| Python        | `None`                                              | emit `null`      | emit `null`      |
+| Go            | absent map entry                                    | **omit the key** | n/a              |
+| Go            | `nil` interface / explicit JSON null                | emit `null`      | emit `null`      |
+| Rust          | absent struct field with `skip_serializing_if=None` | **omit the key** | n/a              |
+| Rust          | `Option::None` serialized without skip             | emit `null`      | emit `null`      |
+| Rust          | `Value::Null`                                       | emit `null`      | emit `null`      |
 
 ```
-input    → { a: 1, b: undefined, c: 3 }
+input    → { a: 1, b: undefined, c: 3 }   (TS)
 output   → {"a":1,"c":3}
 
-input    → [1, undefined, 3]
+input    → [1, undefined, 3]              (TS)
 output   → [1,null,3]
+
+input    → {"a": 1, "b": None, "c": 3}    (Python)
+output   → {"a":1,"b":null,"c":3}
 ```
 
-This is intentionally asymmetric: an object with an absent key and an
-object with `b: undefined` produce identical output, matching JSON's
-inability to express "absent vs undefined-valued" distinctly. Inside an
-array the position is meaningful, so `undefined` materializes as `null`.
+This is intentionally asymmetric: in TypeScript, an object with an
+absent key and an object with `b: undefined` produce identical output,
+matching JSON's inability to express "absent vs undefined-valued"
+distinctly. Inside an array the position is meaningful, so
+`undefined` materializes as `null`.
 
-Python (`None`), Go (`nil`), and Rust (`Option::None` mapped to
-`Value::Null`) do not expose `undefined` as a distinct value; they MUST
-serialize a null-equivalent input as JSON `null`. SDKs MUST NOT invent
-an `undefined` channel where the host language has none.
+SDKs MUST NOT invent an `undefined` channel where the host language has
+none. Python `None`, Go `nil` of an interface type that produced a JSON
+null on parse, and Rust `Value::Null` all map to JSON `null`.
 
 ### Rule 7 — Booleans
 
@@ -159,6 +173,36 @@ input    → []
 output   → []
 ```
 
+### Rule 9 — Unicode normalization is OUT OF SCOPE
+
+Strings are emitted as their UTF-8 byte sequence with the escaping
+rules of Rule 3, **without** any Unicode normalization (NFC, NFD,
+NFKC, NFKD). A producer that supplies the precomposed string `"é"`
+(U+00E9) and a producer that supplies the decomposed sequence
+`"e"` + `U+0301` will produce **different bytes**, even though the
+two strings render identically and compare equal under canonical
+equivalence.
+
+This is a deliberate non-decision: requiring a normalization form at
+the canonicalization layer would force every SDK to ship an ICU- or
+unicode-tables-equivalent dependency and would still leave open
+which form (NFC vs NFKC) wins. Applications that care about
+homograph resistance MUST normalize their strings **before** they
+hand the value to the canonicalizer (NFC is the conventional choice
+for JSON-on-the-wire interchange — RFC 8259 § 8.1).
+
+A future profile (`dcp-jcs-v2` or later) MAY pin a normalization form;
+that decision will live in its own profile document.
+
+> Note on `NaN` / `±Infinity`: these values are not part of RFC 8259
+> JSON wire format. Most JSON parsers reject them at parse time, so
+> the canonicalizer never sees them. Where a parser does accept them
+> (e.g. Python `json.loads(allow_nan=True)`, JavaScript hand-built
+> values), Rule 4 still rejects them post-parse. The interop fixtures
+> deliberately do not ship a NaN/Infinity vector because no portable
+> JSON syntax can express them; rejection is verified by per-SDK unit
+> tests (e.g. `sdks/rust/src/v2/canonicalize.rs` `test_rejects_non_finite`).
+
 ---
 
 ## 3. Edge-case acceptance table
diff --git a/spec/DCP-AI-v2.0.md b/spec/DCP-AI-v2.0.md
@@ -234,11 +234,17 @@ The bundle manifest cryptographically binds all artifact hashes:
     "audit_merkle_root": "sha256:...",
     "audit_merkle_root_secondary": "sha3-256:...",
     "audit_count": 5,
-    "pq_checkpoints": ["ckpt-uuid-1"]
+    "pq_checkpoints": ["ckpt-uuid-1"],
+    "canonicalization_profile": "dcp-jcs-v1"
   }
 }
 ```
 
+`canonicalization_profile` is OPTIONAL (only `"dcp-jcs-v1"` defined today;
+see § 15 and [`CANONICALIZATION_PROFILE.md`](CANONICALIZATION_PROFILE.md)).
+A verifier that encounters a bundle without the field MUST assume
+`dcp-jcs-v1`. Future profiles will make the field REQUIRED.
+
 The bundle-level composite signature signs `canonical(manifest)`.
 
 ---

Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,7 @@ func BuildBundleV2(input BundleBuildInput) (*CitizenshipBundleV2, error) {`
`82`	`82`	`AuditMerkleRoot: "sha256:" + auditMerkleSHA256,`
`83`	`83`	`AuditMerkleRootSecondary: "sha3-256:" + auditMerkleSHA3,`
`84`	`84`	`AuditCount: len(input.AuditEntries),`
	`85`	`+ CanonicalizationProfile: "dcp-jcs-v1",`
`85`	`86`	`}`
`86`	`87`
`87`	`88`	`bundle := &CitizenshipBundleV2{`