@openwop/openwop-conformance 2.37.1 → 2.38.0

package/src/lib/llm-cache-key-recipe.ts

@@ -10,30 +10,20 @@
  *     RFC 0041 §E SECURITY-invariant probe (intra-host reproducibility +
  *     non-recipe-field invariance + Phase 4 advertisement alignment).
  *
- * `canonicalize` mirrors RFC 8785 JCS-style output (sorted keys, no
- * whitespace, preserved array order). Hosts that have a real JCS library
- * available SHOULD prefer it; this helper is for the conformance side,
- * not the host side. Keep in sync with `spec/v1/replay.md` §B.
+ * `canonicalize` is RFC 8785 JCS with the RFC 0212 I-JSON refusal set (the
+ * suite's one implementation, `./jcs.ts`), and `tools[]` sorts by UTF-16 code
+ * units — never `localeCompare`, which orders `get_weather` / `getWeather`
+ * differently per locale and so breaks the TS/Python/Go agreement RFC 0150 §C
+ * asks for. Keep in sync with `spec/v1/replay.md` §B.
  */
 
 import { createHash } from 'node:crypto';
 import { driver } from './driver.js';
+import { canonicalJSON, codeUnitCompare } from './jcs.js';
 
-/** RFC 8785 JCS-style canonicalization (subset suitable for the recipe
- *  fields). Sorted keys recursively; no whitespace; preserved array order;
- *  strings JSON-encoded verbatim (no NFC normalization — the recipe
- *  inputs in our test seam are ASCII). */
+/** RFC 8785 JCS (RFC 0212). Throws `JcsRefusal` on a non-I-JSON value. */
 export function canonicalize(value: unknown): string {
-  if (value === null) return 'null';
-  if (typeof value === 'boolean' || typeof value === 'number') return JSON.stringify(value);
-  if (typeof value === 'string') return JSON.stringify(value);
-  if (Array.isArray(value)) return '[' + value.map((v) => canonicalize(v)).join(',') + ']';
-  if (typeof value === 'object') {
-    const obj = value as Record<string, unknown>;
-    const keys = Object.keys(obj).sort();
-    return '{' + keys.map((k) => `${JSON.stringify(k)}:${canonicalize(obj[k])}`).join(',') + '}';
-  }
-  return JSON.stringify(value);
+  return canonicalJSON(value);
 }
 
 /** @deprecated RETIRED v1 projection (pre RFC 0150 §C). Kept ONLY so a
@@ -44,7 +34,7 @@ export function canonicalize(value: unknown): string {
 export function projectRecipe(raw: Record<string, unknown>): Record<string, unknown> {
   const out: Record<string, unknown> = { provider: raw.provider, model: raw.model, messages: raw.messages };
   if (Array.isArray(raw.tools) && raw.tools.length > 0) {
-    out.tools = [...(raw.tools as Array<{ name: string }>)].sort((a, b) => a.name.localeCompare(b.name));
+    out.tools = [...(raw.tools as Array<{ name: string }>)].sort((a, b) => codeUnitCompare(a.name, b.name));
   }
   if (typeof raw.temperature === 'number') out.temperature = raw.temperature;
   if (typeof raw.topP === 'number') out.topP = raw.topP;
@@ -76,7 +66,7 @@ export const SEMANTIC_REQUEST_RECIPE_V2 = 'openwop-semantic-request-v2';
 export function projectSemanticRequestV2(raw: Record<string, unknown>): Record<string, unknown> {
   const request: Record<string, unknown> = { messages: raw.messages };
   if (Array.isArray(raw.tools) && raw.tools.length > 0) {
-    request.tools = [...(raw.tools as Array<{ name: string }>)].sort((a, b) => a.name.localeCompare(b.name));
+    request.tools = [...(raw.tools as Array<{ name: string }>)].sort((a, b) => codeUnitCompare(a.name, b.name));
   }
   for (const k of ['temperature', 'topP', 'topK', 'maxOutputTokens', 'seed'] as const) {
     if (typeof raw[k] === 'number') request[k] = raw[k];

package/src/lib/scoped-receiver.ts

@@ -49,7 +49,7 @@
 
 import { randomBytes } from 'node:crypto';
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
-import { FRONT_MUX_PREFIX, registerBehindFront, routeFronted, unregisterBehindFront } from './front-mux.js';
+import { FRONT_MUX_PREFIX, registerBehindFront, routeFronted, unregisterBehindFront, withoutFrontPath } from './front-mux.js';
 import { receiverBinding, resolvePublicFront } from './webhook-receiver.js';
 
 /** The operator's public front for the suite's webhook receiver. */
@@ -122,7 +122,7 @@ export async function startScopedReceiver(
     // Counted BEFORE routing: `routeFronted` answers an unknown nonce itself and
     // cannot report that it did, and a request that is not this exercise's must
     // still be visible in the failure detail.
-    if (!(request.url ?? '/').startsWith(`${FRONT_MUX_PREFIX}${nonce}`)) foreign += 1;
+    if (!withoutFrontPath(WEBHOOK_FRONT_ENV, request.url ?? '/').startsWith(`${FRONT_MUX_PREFIX}${nonce}`)) foreign += 1;
     if (routeFronted(WEBHOOK_FRONT_ENV, request, res)) return;
     // Not an `/fx/` path at all: a stranger, or a host that dropped the path it
     // was given. Answered, never recorded — a receiver that counts what it was

package/src/scenarios/jcs-vectors.test.ts

@@ -0,0 +1,108 @@
+/**
+ * RFC 0212 — canonical JSON is RFC 8785 (JCS), and the input MUST be I-JSON.
+ *
+ * `conformance/vectors/jcs-v1.json` is normative: every signature and digest in
+ * the corpus (pack signatures, the certification-bundle attestation,
+ * `discovery.sha256`, `witnessSha256`, the RFC 0150 request digest) is over
+ * these bytes, and an SDK in another language reproduces the same file. This
+ * scenario holds the suite's one implementation (`lib/jcs.ts`) to it.
+ *
+ * Every leg RECOMPUTES from the vector input; none compares two constants from
+ * the file. The sabotages RFC 0212 names, each of which turns a leg red:
+ *
+ *   - a rebuild-object canonicalizer (`JSON.stringify` of an object whose keys
+ *     were inserted in sorted order) — integer-like keys enumerate first, so
+ *     `integer-like-keys` fails;
+ *   - NaN → `null` coercion — the value-boundary refusal leg fails;
+ *   - a parser that keeps the last duplicate name (`JSON.parse`) — the
+ *     `duplicate-name` refusal is accepted;
+ *   - a `localeCompare` comparator — the ordering leg and the
+ *     `rfc8785-3.2.3-sort` vector fail.
+ *
+ * Server-free and always-on; the vectors ship with the conformance package.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { canonicalJSON, canonicalizeText, codeUnitCompare, JcsRefusal } from '../lib/jcs.js';
+import { witnessDigest, type BundleV3Requirement } from '../lib/certification-bundle-v3.js';
+import { req } from '../lib/requirement-ids.js';
+
+interface NumberVector { readonly ieee754: string; readonly canonical: string }
+interface NumberRefusal { readonly ieee754: string; readonly refuse: string }
+interface ObjectVector { readonly id: string; readonly why: string; readonly input: string; readonly canonical: string; readonly sha256: string }
+interface RefusalVector { readonly id: string; readonly why: string; readonly input: string; readonly refuse: string }
+interface Ordering { readonly why: string; readonly ids: readonly string[]; readonly codeUnit: readonly string[] }
+
+const VECTORS_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..', 'vectors', 'jcs-v1.json');
+const doc = JSON.parse(readFileSync(VECTORS_PATH, 'utf8')) as {
+  numbers: readonly NumberVector[];
+  numberRefusals: readonly NumberRefusal[];
+  objects: readonly ObjectVector[];
+  refusals: readonly RefusalVector[];
+  ordering: Ordering;
+};
+
+const SPEC = 'RFC 0212 · spec/v2/core/conformance.md §"Canonical JSON"';
+const sha256 = (s: string): string => createHash('sha256').update(s, 'utf8').digest('hex');
+const double = (hex: string): number => Buffer.from(hex, 'hex').readDoubleBE(0);
+
+function refusalOf(fn: () => unknown): JcsRefusal | undefined {
+  try { fn(); } catch (e) { if (e instanceof JcsRefusal) return e; throw e; }
+  return undefined;
+}
+
+describe('RFC 0212 — canonical JSON is RFC 8785 JCS over I-JSON', () => {
+  it('the vector set is present and non-trivial', () => {
+    // An empty or truncated file would make every leg below vacuous.
+    expect(doc.numbers.length, req('openwop.it.jcs-vectors.the-vector-set-is-present-and-non-trivial', SPEC, 'the vectors MUST cover RFC 8785 Appendix B numbers, documents and every §B refusal kind')).toBeGreaterThanOrEqual(20);
+    expect(doc.objects.length).toBeGreaterThanOrEqual(10);
+    expect(new Set(doc.refusals.map((r) => r.refuse))).toEqual(new Set(['duplicate-name', 'lone-surrogate', 'integer-out-of-range', 'not-json', 'non-finite']));
+  });
+
+  it.each(doc.numbers.map((n) => [n.ieee754, n] as const))('number %s serializes per RFC 8785 Appendix B', (_hex, n) => {
+    expect(canonicalJSON(double(n.ieee754)), req('openwop.it.jcs-vectors.number-s-serializes-per-rfc-8785-appendix-b', SPEC, 'numbers MUST serialize as ECMAScript Number::toString (RFC 8785 §3.2.2.3)')).toBe(n.canonical);
+  });
+
+  it.each(doc.objects.map((o) => [o.id, o] as const))('document %s canonicalizes and hashes', (_id, o) => {
+    // The preimage is asserted as well as the hash so a failing implementation
+    // can diff WHICH member it got wrong.
+    const canonical = canonicalizeText(o.input);
+    expect(canonical, req('openwop.it.jcs-vectors.document-s-canonicalizes-and-hashes', SPEC, o.why)).toBe(o.canonical);
+    expect(sha256(canonical), req('openwop.it.jcs-vectors.document-s-canonicalizes-and-hashes', SPEC, o.why)).toBe(o.sha256);
+  });
+
+  it.each(doc.refusals.map((r) => [r.id, r] as const))('text %s is refused, not coerced', (_id, r) => {
+    const refusal = refusalOf(() => canonicalizeText(r.input));
+    expect(refusal?.kind, req('openwop.it.jcs-vectors.text-s-is-refused-not-coerced', SPEC, `RFC 0212 §B: ${r.why}`)).toBe(r.refuse);
+  });
+
+  it('a non-I-JSON native value is refused at the value boundary', () => {
+    const cases: readonly [string, unknown][] = [
+      ...doc.numberRefusals.map((n) => [`ieee754 ${n.ieee754}`, { n: double(n.ieee754) }] as [string, unknown]),
+      ['NaN', { n: Number.NaN }],
+      ['undefined member', { a: undefined }],
+      ['undefined element', [undefined]],
+      ['Date', { at: new Date(0) }],
+      ['bigint', { n: 1n }],
+      ['lone surrogate', { s: '\ud800' }],
+      ['lone surrogate in a name', { '\udc00': 1 }],
+    ];
+    for (const [label, value] of cases) {
+      expect(refusalOf(() => canonicalJSON(value)), req('openwop.it.jcs-vectors.a-non-i-json-native-value-is-refused-at-the-value-boundary', SPEC, `RFC 0212 §B: ${label} MUST be refused, not serialized`)).toBeInstanceOf(JcsRefusal);
+    }
+  });
+
+  it('member names and certification rows sort by UTF-16 code units, not by locale', () => {
+    const o = doc.ordering;
+    expect([...o.ids].sort(codeUnitCompare), req('openwop.it.jcs-vectors.member-names-and-certification-rows-sort-by-utf-16-code-units-not-by-locale', SPEC, o.why)).toEqual([...o.codeUnit]);
+    // The certification digest uses the same comparator (RFC 0212 §C): rows
+    // given in vector order digest to the JCS of the code-unit-sorted rows.
+    const rows: BundleV3Requirement[] = o.ids.map((id) => ({ id, scenario: 's.test.ts', result: 'executed-pass' }) as BundleV3Requirement);
+    const expected = sha256(canonicalJSON([...o.codeUnit].map((id) => ({ id, scenario: 's.test.ts', result: 'executed-pass' }))));
+    expect(witnessDigest(rows), req('openwop.it.jcs-vectors.member-names-and-certification-rows-sort-by-utf-16-code-units-not-by-locale', SPEC, 'witnessSha256 rows MUST sort by id in UTF-16 code-unit order; a locale-sensitive comparator MUST NOT be used')).toBe(expected);
+  });
+});

package/src/scenarios/semantic-digest-vectors.test.ts

@@ -110,6 +110,14 @@ describe('RFC 0150 §C — semantic request digest golden vectors', () => {
     expect(digest('tools-sorted-by-name'), req('openwop.it.semantic-digest-vectors.tool-order-is-not-semantic-sorted-and-reversed-agree', 'RFC 0150 §C', 'tool order is not semantic — sorted and reversed agree')).toBe(digest('tools-reversed-same-digest'));
   });
 
+  it('tool order uses UTF-16 code units, where a locale comparator disagrees', () => {
+    // RFC 0212 §D. `alpha`/`zeta` order the same under every comparator, so the
+    // pair above cannot catch a `localeCompare` sort; `getWeather`/`get_weather`
+    // can — English collation ignores `_` and puts them the other way round.
+    expect(digest('tools-code-unit-order'), req('openwop.it.semantic-digest-vectors.tool-order-uses-utf-16-code-units-where-a-locale-comparator-disagrees', 'RFC 0212 §D · RFC 0150 §C', 'tools[] MUST sort by name in UTF-16 code-unit order')).toBe(digest('tools-code-unit-order-reversed'));
+    expect(canonicalize(projectSemanticRequestV2(byId.get('tools-code-unit-order')?.input ?? {})), req('openwop.it.semantic-digest-vectors.tool-order-uses-utf-16-code-units-where-a-locale-comparator-disagrees', 'RFC 0212 §D · RFC 0150 §C', 'getWeather (0x57) MUST precede get_weather (0x5F)')).toContain('"tools":[{"name":"getWeather"');
+  });
+
   it('message order IS semantic — reversing changes the digest', () => {
     expect(
       digest('message-order-is-semantic'),

package/src/scenarios/v2-a2a-operation-map.test.ts

@@ -25,6 +25,7 @@
  * @see spec/v2/interop-map.json a2a.operations / a2a.taskState / a2a.errors
  * @see RFCS/0208-v2-a2a-mcp-operation-mappings.md §C, §D, §E
  * @see RFCS/0199-outbound-oauth-client-and-credential-interrupt.md §D.1 (the credential leg; interop-map.json a2a.taskState override row)
+ * @see RFCS/0214-a2a-push-credential-is-a-destination-credential.md (the push-config refusal leg; invariants a2a-push-credential-destination-bound, a2a-push-secrets-not-returned)
  * @see RFCS/0211-a2a-error-details-are-errorinfo.md §A–§E (the error-details legs; the isolation comparator)
  */
 import { describe, it, expect } from 'vitest';
@@ -249,6 +250,33 @@ describe('RFC 0208 — v2-a2a-operation-map (host as A2A 1.0 server, gated on a2
     await rpc(t.url, 'CancelTask', { id });
   });
 
+  it('a host not advertising a2a.pushNotifications refuses all four push-config operations with PushNotificationNotSupportedError', async () => {
+    const rid = 'openwop.requirement.0214.a2a-push-unadvertised-refused';
+    const pushDoc = 'interop-map.json a2a.errors PushNotificationNotSupportedError (serverWhen: push config without a2a.pushNotifications) and the push-config operation rows; A2A v1.0.1 §3.3.4';
+    const t = await target(true);
+    if (!t.ok) return skip(t, rid);
+    const a2a = (await familyAdvertised('a2a'))!;
+    if (a2a['pushNotifications'] === true) return softSkip('inapplicable', 'a2a.pushNotifications is advertised — the push-config rows are served here, not refused');
+    const first = await startApprovalTask(t.url);
+    const id = first.task?.id;
+    expect(typeof id, req(rid, DOC, `SendMessage MUST start a task: ${JSON.stringify(first.rpc.error)}`)).toBe('string');
+    // Positive control: the task is readable, so a -32001 below could not be masking the refusal under test.
+    const read = await rpc(t.url, 'GetTask', { id });
+    expect(read.error, req(rid, 'a2a.operations GetTask', `positive control: the task the suite just started MUST be readable (got ${JSON.stringify(read.error)})`)).toBeUndefined();
+    const configId = `conf-0214-${randomBytes(6).toString('hex')}`;
+    const calls: Array<[string, Record<string, unknown>]> = [
+      ['CreateTaskPushNotificationConfig', { taskId: id, url: 'https://push.example.com/openwop-conformance' }],
+      ['GetTaskPushNotificationConfig', { taskId: id, id: configId }],
+      ['ListTaskPushNotificationConfigs', { taskId: id }],
+      ['DeleteTaskPushNotificationConfig', { taskId: id, id: configId }],
+    ];
+    for (const [method, params] of calls) {
+      const r = await rpc(t.url, method, params);
+      expect(r.error?.code, req(rid, pushDoc, `${method} on a host not advertising a2a.pushNotifications MUST be refused PushNotificationNotSupportedError -32003 — not method-not-found -32601 (got ${JSON.stringify(r.error ?? r.result)})`)).toBe(-32003);
+    }
+    await rpc(t.url, 'CancelTask', { id });
+  });
+
   it('ListTasks returns only what listRuns returns to the same Subject; tenant and contextId never select', async () => {
     const other = process.env.OPENWOP_TEST_TENANT_B_API_KEY;
     if (!other) return softSkip('blocked', 'OPENWOP_TEST_TENANT_B_API_KEY (a credential bound to a second tenant) is not set — the cross-caller leg cannot run');

package/src/scenarios/v2-a2ui-v09-surface.test.ts

@@ -44,6 +44,7 @@ const CATALOG = 'https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json
 const clone = <T>(o: T): T => JSON.parse(JSON.stringify(o)) as T;
 const POSITIVE = JSON.parse(readFileSync(join(FIXTURES_DIR, 'a2ui-v09', 'positive-approve-brief.json'), 'utf8')) as Json;
 const V1_SURFACE: Json = { catalogVersion: '0.9.1', surface: { title: 'Kickoff', components: [{ component: 'heading', text: 'Kickoff', level: 2 }, { component: 'action.button', id: 'go', label: 'Go', action: { target: 'resume' } }] } };
+const V1_LATER: Json = { catalogVersion: '0.9.1', surface: { title: 'Kickoff, later', components: [{ component: 'heading', text: 'Kickoff, later', level: 2 }] } };
 
 let seq = 0;
 const nonce = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -217,8 +218,16 @@ describe('RFC 0209 §C.11 — recorded surfaces are returned as recorded (seam-g
       const sequence = (r.json as { sequence: number }).sequence;
       const events = await eventsOf(runId);
       expect(carries(events, payload), req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.11', 'the run\'s poll MUST return the recorded surface payload byte-equal — no surface is regenerated')).toBe(true);
-      const fork = await driver.post(`/runs/${encodeURIComponent(runId)}:fork`, { mode: 'replay', fromSeq: sequence + 1 });
-      expect(fork.status, req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.11', `POST :fork at fromSeq ${sequence + 1} MUST answer 201, got ${code(fork)}`)).toBe(201);
+      // The surface is the last event of the suspended run, so `sequence + 1`
+      // names no event and runs.md §Fork REQUIRES 422 fork_point_invalid for it.
+      // Record one more envelope on the same surface and fork AT that event:
+      // the surface (sequence < fromSeq) is fixed history, the later one re-executes.
+      const later = await emit(runId, envelope(2, v2(sid('rec'), [dataMsg()])));
+      expect(later.status, req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.9', `an updateDataModel on the live surface MUST be admitted (it supplies the fork point), got ${code(later)}`)).toBe(201);
+      const fromSeq = (later.json as { sequence: number }).sequence;
+      expect(fromSeq > sequence, req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'api/seams-v2.yaml emitA2uiSurface', `a later recording names a later sequence (surface ${sequence}, update ${fromSeq})`)).toBe(true);
+      const fork = await driver.post(`/runs/${encodeURIComponent(runId)}:fork`, { mode: 'replay', fromSeq });
+      expect(fork.status, req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.11', `POST :fork at fromSeq ${fromSeq} (a recorded event after the surface) MUST answer 201, got ${code(fork)}`)).toBe(201);
       const forkId = (fork.json as { runId: string }).runId;
       expect(carries(await eventsOf(forkId), payload), req('openwop.it.v2-a2ui-v09-surface.recorded-as-recorded', 'RFC 0209 §C.11', 'a fork at a fromSeq after the surface MUST carry it unchanged')).toBe(true);
       await done(forkId);
@@ -234,8 +243,13 @@ describe('RFC 0209 §C.11 — recorded surfaces are returned as recorded (seam-g
       expect(r.status, req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', `a version-1 surface at floor 1 MUST be admitted, got ${code(r)}`)).toBe(201);
       const sequence = (r.json as { sequence: number }).sequence;
       expect(carries(await eventsOf(runId), V1_SURFACE), req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', 'the poll MUST return the version-1 surface byte-equal')).toBe(true);
-      const fork = await driver.post(`/runs/${encodeURIComponent(runId)}:fork`, { mode: 'replay', fromSeq: sequence + 1 });
-      expect(fork.status, req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', `POST :fork MUST answer 201, got ${code(fork)}`)).toBe(201);
+      // As in the version-2 leg: fork at a recorded event after the surface, never at `sequence + 1` (no such event; 422 fork_point_invalid).
+      const later = await emit(runId, envelope(1, V1_LATER));
+      expect(later.status, req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', `a second version-1 surface at floor 1 MUST be admitted (it supplies the fork point), got ${code(later)}`)).toBe(201);
+      const fromSeq = (later.json as { sequence: number }).sequence;
+      expect(fromSeq > sequence, req('openwop.requirement.0209.legacy-readable', 'api/seams-v2.yaml emitA2uiSurface', `a later recording names a later sequence (surface ${sequence}, next ${fromSeq})`)).toBe(true);
+      const fork = await driver.post(`/runs/${encodeURIComponent(runId)}:fork`, { mode: 'replay', fromSeq });
+      expect(fork.status, req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', `POST :fork at fromSeq ${fromSeq} (a recorded event after the surface) MUST answer 201, got ${code(fork)}`)).toBe(201);
       const forkId = (fork.json as { runId: string }).runId;
       expect(carries(await eventsOf(forkId), V1_SURFACE), req('openwop.requirement.0209.legacy-readable', 'RFC 0209 §C.11', 'a fork at a later fromSeq MUST carry the version-1 surface unchanged')).toBe(true);
       await done(forkId);

package/src/scenarios/v2-content-locale-keys.test.ts

@@ -21,6 +21,11 @@
  * `Content-Language` names the tag (case-insensitively, RFC 5646 §2.1.1) and
  * the section carries the overlay.
  *
+ * Gate: the family is advertised by the PRESENCE of its record
+ * (`familyAdvertised`, RFC 0169 §A.2) — never by a `supported` flag, which the
+ * closed v2 `content` record cannot carry. `v2-family-gate-no-supported.test.ts`
+ * (a suite self-test) keeps that gate from coming back.
+ *
  * Sabotage: a host that 400s the extended-tag write, or that serves only the
  * base locale for it, fails the leg (write status / `Content-Language` /
  * overlay assertion respectively).
@@ -52,7 +57,11 @@ describe('v2-content-locale-keys (RFC 0206)', () => {
     const doc = await v2Discovery().catch(() => null);
     if (doc === null) return softSkip('blocked', 'v2 discovery unreachable');
     const content = await familyAdvertised('content');
-    if (content === null || content['supported'] !== true) return softSkip('inapplicable', 'the host does not advertise the content family (no content surface to deliver an extended locale from)');
+    // RFC 0169 §A.2: at major 2 the record's presence IS the claim. The v2
+    // `content` record is closed and has no `supported` field, so a gate on
+    // `supported === true` recorded `inapplicable` on every conforming host and
+    // this row could never execute (corrected 2026-09-24).
+    if (content === null) return softSkip('inapplicable', 'the host does not advertise the content family (no content surface to deliver an extended locale from)');
     const base = typeof content['baseLocale'] === 'string' ? content['baseLocale'] : null;
     const supported = Array.isArray(content['supportedLocales']) ? content['supportedLocales'].filter((x): x is string => typeof x === 'string') : [];
     const keyRe = new RegExp(LOCALE_KEY_PATTERN);

package/src/scenarios/v2-mrtr-rounds-ceiling.test.ts

@@ -85,7 +85,13 @@ describe('RFC 0175 §E.1 — mrtr-rounds-ceiling (gated on mcp + mrtr)', () => {
     if (!loopKnown) {
       return softSkip('blocked', `the suite MCP fake server cannot loop — its only MRTR tool (needs_input) completes on the first retry; a \`${LOOP_TOOL}\` fixture tool that re-issues input_required ${rounds} times is required to drive maxRounds + 1`);
     }
-    expect(res.status, req('openwop.requirement.0175.mrtr-rounds-ceiling.refused', 'interop.md §The MCP round ceiling', `round ${rounds} (maxRounds + 1) MUST be refused with 422`)).toBe(422);
+    // The failure message carries the host's code, the fake's count and the
+    // body (2.38.0). The 2026-09-24 public v2-reference cut on 2.37.1 recorded
+    // `expected 400 to be 422` and nothing else — the same leg passes on every
+    // loopback run of that host — so whether the 400 was the host refusing a
+    // round the fake answered, or a round the tunnel failed to carry, could not
+    // be read from the record.
+    expect(res.status, req('openwop.requirement.0175.mrtr-rounds-ceiling.refused', 'interop.md §The MCP round ceiling', `round ${rounds} (maxRounds + 1) MUST be refused with 422 (got ${res.status} ${String(readErrorCode(res.json))}; the fake served ${served.length} tools/call; body ${res.text.slice(0, 400)})`)).toBe(422);
     expect(readErrorCode(res.json), req('openwop.requirement.0175.mrtr-rounds-ceiling.refused', 'errors.json mcp_mrtr_rounds_exceeded', `the refusal MUST carry ${CODE}`)).toBe(CODE);
     expect(
       served.length,

package/src/scenarios/v2-oauth-client-pkce-state-iss.test.ts

@@ -118,7 +118,13 @@ describe('RFC 0199 §A — v2-oauth-client-pkce-state-iss (host as OAuth client,
     n = d.codeExchanges().length;
     const replay = await userAgentGet(cbA!, key);
     expect([replay.status >= 400, d.codeExchanges().length], req(id, `${DOC} rule 2`, `a replayed (already consumed) state MUST be refused with no token request (got ${replay.status})`)).toEqual([true, n]);
-  });
+    // 120 s, not the 30 s default (2.38.0): this leg makes eight sequential
+    // round trips — two grants, two consents, four callbacks — and on a public
+    // cut every one crosses the operator's tunnel to the AS double. The
+    // 2026-09-24 public v2-reference cut on 2.37.1 timed out here at 30 s while
+    // the sibling legs (pkce-s256, iss-validated, same-user-callback), which
+    // make fewer trips, passed. No assertion or window inside the leg changes.
+  }, 120_000);
 
   it('a callback authenticated as another Subject makes no token request and stores nothing', async () => {
     const r = await ready();

package/vectors/jcs-v1.json

@@ -0,0 +1,294 @@
+{
+  "$comment": [
+    "RFC 0212 — cross-language vectors for canonical JSON (RFC 8785 JCS) with the OpenWOP I-JSON refusal set.",
+    "Every signed or hashed preimage in the corpus MUST reproduce `canonical` and `sha256` for each `objects` entry, `canonical` for each `numbers` entry, and MUST refuse each `refusals` entry with a refusal (the `refuse` kind is informative).",
+    "Generated by a reference implementation that parses JSON TEXT (so duplicates, integer magnitude and lone surrogates are visible before coercion) and cross-checked against RFC 8785 Appendix B and §3.2.2/§3.2.3."
+  ],
+  "spec": "RFC 8785; RFC 7493 (I-JSON); RFC 0212",
+  "hash": "sha256, lowercase hex, over the UTF-8 bytes of `canonical`",
+  "numbers": [
+    {
+      "ieee754": "0000000000000000",
+      "canonical": "0"
+    },
+    {
+      "ieee754": "8000000000000000",
+      "canonical": "0"
+    },
+    {
+      "ieee754": "0000000000000001",
+      "canonical": "5e-324"
+    },
+    {
+      "ieee754": "8000000000000001",
+      "canonical": "-5e-324"
+    },
+    {
+      "ieee754": "7fefffffffffffff",
+      "canonical": "1.7976931348623157e+308"
+    },
+    {
+      "ieee754": "ffefffffffffffff",
+      "canonical": "-1.7976931348623157e+308"
+    },
+    {
+      "ieee754": "4340000000000000",
+      "canonical": "9007199254740992"
+    },
+    {
+      "ieee754": "c340000000000000",
+      "canonical": "-9007199254740992"
+    },
+    {
+      "ieee754": "4430000000000000",
+      "canonical": "295147905179352830000"
+    },
+    {
+      "ieee754": "44b52d02c7e14af5",
+      "canonical": "9.999999999999997e+22"
+    },
+    {
+      "ieee754": "44b52d02c7e14af6",
+      "canonical": "1e+23"
+    },
+    {
+      "ieee754": "44b52d02c7e14af7",
+      "canonical": "1.0000000000000001e+23"
+    },
+    {
+      "ieee754": "444b1ae4d6e2ef4e",
+      "canonical": "999999999999999700000"
+    },
+    {
+      "ieee754": "444b1ae4d6e2ef4f",
+      "canonical": "999999999999999900000"
+    },
+    {
+      "ieee754": "444b1ae4d6e2ef50",
+      "canonical": "1e+21"
+    },
+    {
+      "ieee754": "3eb0c6f7a0b5ed8c",
+      "canonical": "9.999999999999997e-7"
+    },
+    {
+      "ieee754": "3eb0c6f7a0b5ed8d",
+      "canonical": "0.000001"
+    },
+    {
+      "ieee754": "41b3de4355555553",
+      "canonical": "333333333.3333332"
+    },
+    {
+      "ieee754": "41b3de4355555554",
+      "canonical": "333333333.33333325"
+    },
+    {
+      "ieee754": "41b3de4355555555",
+      "canonical": "333333333.3333333"
+    },
+    {
+      "ieee754": "41b3de4355555556",
+      "canonical": "333333333.3333334"
+    },
+    {
+      "ieee754": "41b3de4355555557",
+      "canonical": "333333333.33333343"
+    },
+    {
+      "ieee754": "becbf647612f3696",
+      "canonical": "-0.0000033333333333333333"
+    },
+    {
+      "ieee754": "43143ff3c1cb0959",
+      "canonical": "1424953923781206.2"
+    }
+  ],
+  "numberRefusals": [
+    {
+      "ieee754": "7fffffffffffffff",
+      "refuse": "non-finite"
+    },
+    {
+      "ieee754": "7ff0000000000000",
+      "refuse": "non-finite"
+    }
+  ],
+  "objects": [
+    {
+      "id": "rfc8785-3.2.2",
+      "why": "RFC 8785 §3.2.2 worked example: number shortest-round-trip, string escapes, member sort.",
+      "input": "{\"numbers\": [333333333.33333329, 1E30, 4.50, 2e-3, 0.000000000000000000000000001], \"string\": \"\\u20ac$\\u000F\\u000aA'\\u0042\\u0022\\u005c\\\\\\\"\\/\", \"literals\": [null, true, false]}",
+      "canonical": "{\"literals\":[null,true,false],\"numbers\":[333333333.3333333,1e+30,4.5,0.002,1e-27],\"string\":\"€$\\u000f\\nA'B\\\"\\\\\\\\\\\"/\"}",
+      "sha256": "2d5e01a318d0f0879ab568c4be289c8b1f64ef8921a53c6277d5e069978baacb"
+    },
+    {
+      "id": "rfc8785-3.2.3-sort",
+      "why": "RFC 8785 §3.2.3: members sorted by UTF-16 code units — CR, \"1\", U+0080, ö, €, 😀 (surrogate pair D83D), דּ (FB33). Locale collation gives a different order.",
+      "input": "{\"€\":\"Euro Sign\",\"\\r\":\"Carriage Return\",\"דּ\":\"Hebrew Letter Dalet With Dagesh\",\"1\":\"One\",\"😀\":\"Emoji: Grinning Face\",\"\\u0080\":\"Control\",\"ö\":\"Latin Small Letter O With Diaeresis\"}",
+      "canonical": "{\"\\r\":\"Carriage Return\",\"1\":\"One\",\"€\":\"Control\",\"ö\":\"Latin Small Letter O With Diaeresis\",\"€\":\"Euro Sign\",\"😀\":\"Emoji: Grinning Face\",\"דּ\":\"Hebrew Letter Dalet With Dagesh\"}",
+      "sha256": "5e321556d22018a9656991a9e94f77ec175fa193e52a2429d312f8419ec8b08c"
+    },
+    {
+      "id": "integer-like-keys",
+      "why": "Keys \"10\" and \"9\" sort by code unit (\"1\" < \"9\"). A canonicalizer that rebuilds a JS object and calls JSON.stringify emits {\"9\":…,\"10\":…} — the sabotage this vector exists for.",
+      "input": "{\"9\":\"nine\",\"10\":\"ten\",\"a\":0}",
+      "canonical": "{\"10\":\"ten\",\"9\":\"nine\",\"a\":0}",
+      "sha256": "ac5e0767681af2d226a2a4df567cee9cd3254a7819a7643f8bddbfa690792dad"
+    },
+    {
+      "id": "nested-sort",
+      "why": "Sorting applies at every level; arrays keep their order.",
+      "input": "{\"b\":[{\"z\":1,\"a\":2},{\"y\":[3,1,2]}],\"a\":{\"d\":null,\"c\":true}}",
+      "canonical": "{\"a\":{\"c\":true,\"d\":null},\"b\":[{\"a\":2,\"z\":1},{\"y\":[3,1,2]}]}",
+      "sha256": "fc8d1753fb837b89a49b6335715adb82c262e9a6bbfe7f4e7b8993e297951cca"
+    },
+    {
+      "id": "control-escapes",
+      "why": "U+0000–U+001F: short forms for \\b \\t \\n \\f \\r, lowercase \\u00xx otherwise; U+007F and U+2028 are emitted raw; \"/\" is not escaped.",
+      "input": "{\"s\":\"\\u0000\\u0007\\b\\t\\n\\u000b\\f\\r\\u001f\\u007f
/\"}",
+      "canonical": "{\"s\":\"\\u0000\\u0007\\b\\t\\n\\u000b\\f\\r\\u001f
/\"}",
+      "sha256": "993e6efcefb9f0bc08a2f896edce693cd6e80aa50ed6337ae0921b06a656c1a3"
+    },
+    {
+      "id": "non-ascii-raw",
+      "why": "Non-ASCII is emitted as raw UTF-8, never \\u-escaped (em dash, as in 625 registry pack strings).",
+      "input": "{\"title\":\"a — b\",\"emoji\":\"😀\"}",
+      "canonical": "{\"emoji\":\"😀\",\"title\":\"a — b\"}",
+      "sha256": "d2a26872e24a775a770515e000f1bb85a0949c08b40621292b7e70037006d02d"
+    },
+    {
+      "id": "nfc-composed",
+      "why": "U+00E9 (composed). MUST NOT hash equal to the decomposed vector: JCS applies no Unicode normalization.",
+      "input": "{\"name\":\"café\"}",
+      "canonical": "{\"name\":\"café\"}",
+      "sha256": "645fa443126a8954fc6d871912b8fc67bc2ee8feae417efe55546251962ca74d"
+    },
+    {
+      "id": "nfd-decomposed",
+      "why": "U+0065 U+0301 (decomposed). Pair with nfc-composed.",
+      "input": "{\"name\":\"café\"}",
+      "canonical": "{\"name\":\"café\"}",
+      "sha256": "4b7186ff40a64bfae3cb4bd75ac13b0de5ee693190f20812aaff208a77560ca7"
+    },
+    {
+      "id": "numbers-in-document",
+      "why": "Numbers inside a document: -0 → 0, 1.0 → 1, 1e21 → 1e+21, 1e-7 → 1e-7, 0.1+0.2 shortest form, 2^53−1 accepted.",
+      "input": "{\"n\":[-0,1.0,1e21,1e-7,0.30000000000000004,9007199254740991,-9007199254740991]}",
+      "canonical": "{\"n\":[0,1,1e+21,1e-7,0.30000000000000004,9007199254740991,-9007199254740991]}",
+      "sha256": "430e3fefe48227fd5ed7df3ba8b5a6da008c2077858a44bd265d4c7812c498c1"
+    },
+    {
+      "id": "empty-containers",
+      "why": "Empty object and array.",
+      "input": "{\"a\":{},\"b\":[]}",
+      "canonical": "{\"a\":{},\"b\":[]}",
+      "sha256": "aeeba1e56a144077f89e26c930dad7cf933e9383cfb8e33ddff618233b29be76"
+    }
+  ],
+  "refusals": [
+    {
+      "id": "duplicate-name",
+      "why": "I-JSON §2.3: duplicate member names.",
+      "input": "{\"a\":1,\"a\":2}",
+      "refuse": "duplicate-name"
+    },
+    {
+      "id": "lone-high-surrogate",
+      "why": "I-JSON §2.1: a lone surrogate is not a Unicode scalar value.",
+      "input": "{\"s\":\"\\ud800\"}",
+      "refuse": "lone-surrogate"
+    },
+    {
+      "id": "lone-low-surrogate",
+      "why": "I-JSON §2.1.",
+      "input": "{\"s\":\"x\\udc00\"}",
+      "refuse": "lone-surrogate"
+    },
+    {
+      "id": "integer-above-range",
+      "why": "Integer literal 2^53+1 exceeds ±(2^53−1) (I-JSON §2.2); a double cannot hold it exactly and a Python verifier would keep it exact — the two canonical forms differ.",
+      "input": "{\"n\":9007199254740993}",
+      "refuse": "integer-out-of-range"
+    },
+    {
+      "id": "integer-below-range",
+      "why": "Integer literal −2^53.",
+      "input": "{\"n\":-9007199254740992}",
+      "refuse": "integer-out-of-range"
+    },
+    {
+      "id": "nan-token",
+      "why": "NaN is not JSON. A JS canonicalizer given an in-memory NaN MUST refuse, not emit null.",
+      "input": "{\"n\":NaN}",
+      "refuse": "not-json"
+    },
+    {
+      "id": "infinity-overflow",
+      "why": "1e400 parses to Infinity: non-finite.",
+      "input": "{\"n\":1e400}",
+      "refuse": "non-finite"
+    }
+  ],
+  "ordering": {
+    "why": "witnessSha256 rows[] and RFC 0150 tools[] sort by UTF-16 code units of the key. Locale collation disagrees in both listed locales; a verifier using either computes a different digest.",
+    "ids": [
+      "d",
+      "h",
+      "ch",
+      "i",
+      "chain-pin-exact",
+      "h2",
+      "get_weather",
+      "getWeather",
+      "A",
+      "a",
+      "a-b",
+      "ab"
+    ],
+    "codeUnit": [
+      "A",
+      "a",
+      "a-b",
+      "ab",
+      "ch",
+      "chain-pin-exact",
+      "d",
+      "getWeather",
+      "get_weather",
+      "h",
+      "h2",
+      "i"
+    ],
+    "localeCs": [
+      "a",
+      "A",
+      "a-b",
+      "ab",
+      "d",
+      "get_weather",
+      "getWeather",
+      "h",
+      "h2",
+      "ch",
+      "chain-pin-exact",
+      "i"
+    ],
+    "localeEn": [
+      "a",
+      "A",
+      "a-b",
+      "ab",
+      "ch",
+      "chain-pin-exact",
+      "d",
+      "get_weather",
+      "getWeather",
+      "h",
+      "h2",
+      "i"
+    ],
+    "differsFromCs": true,
+    "differsFromEn": true
+  }
+}