@openwop/openwop-conformance 2.37.0 → 2.38.0

package/src/lib/scoped-receiver.ts

@@ -0,0 +1,223 @@
+/**
+ * A webhook receiver that owns its destination — one exercise, one identity.
+ *
+ * ── Why this file exists (2.37.0) ────────────────────────────────────────────
+ * Five surfaces in this suite bind `OPENWOP_WEBHOOK_RECEIVER_PORT`, and on a
+ * tunnelled cut four of them registered `resolveRegistrationUrl(...)`, which
+ * returns `OPENWOP_WEBHOOK_RECEIVER_URL` VERBATIM — one byte-identical string
+ * for every caller. `v2-bound-id-kinds`, `v2-webhook-delivery-shape`,
+ * `v2-webhook-durable-delivery` and `webhook-signed-delivery` therefore pointed
+ * four subscriptions at ONE destination.
+ *
+ * A webhook subscription is durable host-side state. It keeps delivering, and
+ * RETRYING, after the file that created it has finished, so the collision is not
+ * only between two live listeners — it is between an exercise and the leftovers
+ * of an earlier one. Whichever receiver held the pinned port read those
+ * leftovers as its own traffic, and `v2-webhook-durable-delivery` answers 500 BY
+ * DESIGN for the first attempts of every delivery key, so the exercise it landed
+ * on saw failures it never caused. `v2-webhook-delivery-shape`'s own
+ * `startReceiver` carried a comment describing the symptom from the other end:
+ * "the tunnel forwards to the PINNED port — held by the other receiver, which
+ * answers 500 by design — so this file's `deliveries` stays empty, its legs
+ * soft-skip, and the rows resolve `executed-pass`." A wire-shape scenario that
+ * never opened a delivery body went green.
+ *
+ * This is the class openwop#1513 (two legs, one effect identity) and
+ * openwop#1520 (many fakes, one public front) already opened. Those two supply
+ * the halves, and this composes them rather than reimplementing either:
+ *
+ *   - ROUTING is `front-mux.ts`. Several receivers can be alive behind one
+ *     front; each registers its handler under its nonce and calls `routeFronted`
+ *     first, so a delivery reaches the receiver it was ADDRESSED to whichever
+ *     listener happens to hold the port.
+ *   - IDENTITY is here, and it is why the nonce is UNCONDITIONAL rather than
+ *     `frontedEndpoint`'s "only when this fake does not own the pinned port".
+ *     Routing alone does not close a webhook: a bare front is one identity
+ *     shared ACROSS TIME, so a retry aimed at a finished exercise arrives
+ *     indistinguishable from this one's traffic. With the nonce always present
+ *     that retry addresses a nonce this listener does not serve, `routeFronted`
+ *     answers it 404, and it is counted as `foreign()` — never as a delivery.
+ *
+ * What this does NOT do is relax any gate. The destination is still the
+ * operator's own front or loopback; `resolvePublicFront` still refuses a
+ * non-https or private front; `receiverBinding` still binds loopback unless the
+ * operator declared otherwise. Only the PATH changed.
+ *
+ * @see lib/front-mux.ts (routing), lib/effect-receiver.ts (the same nonce idea
+ *      for an outbound effect's Layer-2 identity)
+ */
+
+import { randomBytes } from 'node:crypto';
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
+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. */
+export const WEBHOOK_FRONT_ENV = 'OPENWOP_WEBHOOK_RECEIVER_URL';
+
+type HeaderBag = Record<string, string | string[] | undefined>;
+
+/** One request addressed to THIS exercise. */
+export interface ScopedHit {
+  /** The path as this receiver sees it — the `/fx/<nonce>` prefix already stripped. */
+  readonly path: string;
+  readonly method: string;
+  readonly headers: HeaderBag;
+  readonly body: string;
+}
+
+export interface ScopedReceiver {
+  readonly server: Server;
+  /**
+   * The destination to REGISTER with the host: the public front when one is
+   * wired, else this listener's own address — this exercise's nonce path
+   * appended either way.
+   */
+  readonly url: string;
+  readonly tunnelled: boolean;
+  /** The local address this listener actually answers on — for failure detail. */
+  readonly localUrl: string;
+  /** What makes this exercise's destination, and so its subscription, its own. */
+  readonly nonce: string;
+  /** The port this listener bound — the pinned one when the operator pinned it. */
+  readonly port: number;
+  /**
+   * Requests that reached this listener bearing some OTHER exercise's nonce, or
+   * none at all. Reported so a scenario can say WHY it saw nothing; never handed
+   * to the scenario's recorder.
+   */
+  foreign(): number;
+  close(): Promise<void>;
+}
+
+/**
+ * Start a receiver for exactly one exercise.
+ *
+ * `respond` is called ONLY for this exercise's own requests, and sees the path
+ * with the nonce prefix stripped — exactly what it would see on a listener of
+ * its own. It owns the response.
+ */
+export async function startScopedReceiver(
+  respond: (hit: ScopedHit, res: ServerResponse) => void,
+): Promise<ScopedReceiver> {
+  const nonce = randomBytes(9).toString('hex');
+  let foreign = 0;
+  const own = (request: IncomingMessage, res: ServerResponse): void => {
+    const chunks: Buffer[] = [];
+    request.on('data', (c: Buffer) => chunks.push(c));
+    request.on('end', () => {
+      respond(
+        {
+          path: request.url ?? '/',
+          method: request.method ?? '',
+          headers: request.headers,
+          body: Buffer.concat(chunks).toString('utf8'),
+        },
+        res,
+      );
+    });
+  };
+  registerBehindFront(WEBHOOK_FRONT_ENV, nonce, own);
+  const server = createServer((request: IncomingMessage, res: ServerResponse) => {
+    // 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 (!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
+    // not addressed to is the defect this helper exists to remove.
+    request.resume();
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'this receiver serves one conformance exercise; address its nonce path' }));
+  });
+  const pinned = Number(process.env['OPENWOP_WEBHOOK_RECEIVER_PORT'] ?? '');
+  const bindPort = Number.isInteger(pinned) && pinned > 0 && pinned < 65536 ? pinned : 0;
+  const binding = receiverBinding();
+  await new Promise<void>((resolve) => server.listen(bindPort, binding.bind, () => resolve()));
+  const addr = server.address();
+  if (typeof addr !== 'object' || addr === null) throw new Error('receiver address unavailable');
+  const origin = `http://${binding.advertise}:${addr.port}`;
+  const front = resolvePublicFront(WEBHOOK_FRONT_ENV, origin);
+  return {
+    server,
+    url: `${front.url.replace(/\/+$/, '')}${FRONT_MUX_PREFIX}${nonce}`,
+    tunnelled: front.tunnelled,
+    localUrl: `${origin}${FRONT_MUX_PREFIX}${nonce}`,
+    nonce,
+    port: addr.port,
+    foreign: () => foreign,
+    close: () =>
+      new Promise<void>((resolve) => {
+        unregisterBehindFront(WEBHOOK_FRONT_ENV, nonce);
+        server.close(() => resolve());
+      }),
+  };
+}
+
+/**
+ * A destination for an exercise that must REGISTER a subscription but wants no
+ * delivery — the mint leg of `v2-bound-id-kinds`, say, which needs a 201 and a
+ * bound id and nothing else.
+ *
+ * Such a leg still has to honour the operator's front, or its registration is
+ * refused by an SSRF guard doing its job and the leg records `blocked` on every
+ * public cut. But handing it the front VERBATIM gives it the same identity as
+ * every other exercise, and a subscription is live from the 201 until the
+ * DELETE: anything the host fans out in that window lands on whichever listener
+ * holds the port and is read as that exercise's traffic.
+ *
+ * So it gets a nonce too. No receiver serves it, which is the point: a delivery
+ * to this destination is answered 404 by whichever scoped receiver owns the
+ * port rather than being absorbed into that exercise's record.
+ */
+export function unservedDestination(fallbackUrl: string): { url: string; tunnelled: boolean; nonce: string } {
+  const nonce = randomBytes(9).toString('hex');
+  const front = resolvePublicFront(WEBHOOK_FRONT_ENV, fallbackUrl);
+  return {
+    url: `${front.url.replace(/\/+$/, '')}${FRONT_MUX_PREFIX}${nonce}`,
+    tunnelled: front.tunnelled,
+    nonce,
+  };
+}
+
+/**
+ * Why a scoped receiver saw NO request of its own — the cause a `blocked` row
+ * must name (RFC 0148 §A: anything other than `executed-pass` MUST say why).
+ *
+ * A zero here is not by itself evidence that the host failed to deliver, and
+ * `foreign()` is what tells the two apart:
+ *
+ *   - `foreign() > 0` — traffic DID reach this listener, addressed to another
+ *     nonce or to no nonce at all. The path between the host and this process
+ *     works, so "the host did not deliver" is not what was observed; what was
+ *     observed is that nothing arrived under THIS exercise's identity. That is
+ *     unmeasured, not unmet, and callers record `blocked`.
+ *   - `foreign() === 0` — nothing reached this listener at all. That is still
+ *     ambiguous (a front not wired to this process, or a host that never called
+ *     out), and callers keep whichever disposition the leg already carried; this
+ *     function only supplies the sentence that says which address was in play.
+ *
+ * Either way the record names the observation rather than a conclusion, so a
+ * reader can act on it without hand-probing production.
+ */
+export function noDeliveryCause(rx: ScopedReceiver, what = 'delivery'): string {
+  const where = rx.tunnelled
+    ? `the registered destination is the public front ${rx.url} (${WEBHOOK_FRONT_ENV}) and this listener answers on ${rx.localUrl}, port ${rx.port}`
+    : `the registered destination is this listener at ${rx.url}, port ${rx.port}`;
+  const strangers = rx.foreign();
+  if (strangers > 0) {
+    return `no ${what} bearing this exercise's nonce ${rx.nonce} arrived, but ${strangers} request(s) DID reach this listener addressed elsewhere — so the path from the host to this process works and the absence is of this exercise's identity, not of traffic (${where})`;
+  }
+  return `no ${what} bearing this exercise's nonce ${rx.nonce} arrived, and nothing else reached this listener either — ${where}`;
+}
+
+/**
+ * True when a zero observation is provably NOT a verdict about the host: other
+ * traffic reached this listener, so the absence is of this exercise's identity
+ * rather than of delivery. Callers record `blocked` (which denies certification
+ * exactly as a failure does, RFC 0168 §E.1) instead of convicting the host.
+ */
+export function absenceIsUnmeasured(rx: ScopedReceiver): boolean {
+  return rx.foreign() > 0;
+}

package/src/lib/triggerBridge.ts

@@ -20,6 +20,7 @@
  * @see spec/v1/trigger-bridge.md
  * @see spec/v1/profiles.md (§openwop-trigger-bridge)
  */
+import { randomBytes, randomInt } from 'node:crypto';
 import { driver } from './driver.js';
 import { deriveProfiles, type DiscoveryPayload } from './profiles.js';
 
@@ -70,5 +71,53 @@ export async function driveDelivery(
   return (res.json as DeliveryResult | undefined) ?? {};
 }
 
+/**
+ * A dedup key that belongs to ONE exercise (2.37.0).
+ *
+ * `trigger-bridge.md` §C-1 makes the dedup window a ≥24h FLOOR, so a LITERAL
+ * dedup key is not a fixture — it is a durable identity the host is required to
+ * remember across runs of this suite. Two exercises that hand the bridge the
+ * same key are ONE delivery by the spec's own rule, and the second one's row
+ * reads zero deliveries on a host doing exactly what it MUST. That is a suite
+ * defect and not a host defect, and it is the same failure the RFC 0158
+ * duplicate-delivery row had when two scenario files shared one effect identity
+ * (`lib/effect-receiver.ts`).
+ *
+ * `prefix` keeps a key readable in a host's own log; the random half is what
+ * makes it this exercise's. `randomBytes`, not `Date.now()`: two vitest workers
+ * can enter the same line in the same millisecond.
+ */
+export function freshDedupKey(prefix: string): string {
+  return `openwop-conformance-${prefix}-${randomBytes(9).toString('hex')}`;
+}
+
+/**
+ * The same per-exercise mint for a `stream` source, in the COORDINATE shape
+ * §F.5 keys on (2.37.0).
+ *
+ * `trigger-stream-cdc-sources.test.ts` handed the seam the literal
+ * `'events:3:99001'` and then asserted `deliveredCount === 1 || outcome ===
+ * 'delivered'` — the identical defect `freshDedupKey` above was written for,
+ * one file over, found when the enumeration was re-run against the merged
+ * tree. §C-1's window is a ≥24h floor and §F.5 reuses it verbatim, so the
+ * second run of that file against the same host, any time that day, hands the
+ * bridge broker coordinates it has already delivered; a CONFORMANT host
+ * collapses the exercise into the first run's outcome and the assertion
+ * convicts it. Cold host passes, warm host fails.
+ *
+ * `freshDedupKey` would not do here, and the difference is not cosmetic: §F.5
+ * says a stream event's dedup key SHOULD derive from
+ * `(topic, partition, offset)`, and the leg's own `req()` message asserts over
+ * exactly that keying. An opaque token would make the message describe
+ * something the call no longer does. So topic and partition stay fixed and the
+ * OFFSET is minted — which is precisely what makes a real broker's message a
+ * different message.
+ */
+export function freshStreamDedupKey(topic = 'events', partition = 3): string {
+  // A 2^44 offset space: distinct across every run this suite will make, and
+  // still a plausible broker offset rather than an opaque token.
+  return `${topic}:${partition}:${randomInt(2 ** 44)}`;
+}
+
 export const SUBSCRIPTION_STATES = ['active', 'paused', 'failed', 'dead-lettered'];
 export const DELIVERY_OUTCOMES = ['delivered', 'retrying', 'dead-lettered'];

package/src/scenarios/auth-subject-link.test.ts

@@ -23,6 +23,7 @@
  * @see spec/v1/auth-profiles.md §"Subject linking (SAML ⟷ SCIM)"
  */
 
+import { randomBytes } from 'node:crypto';
 import { describe, it, expect } from 'vitest';
 import { softSkip, seamAbsent } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
@@ -109,7 +110,23 @@ describe('auth-subject-link: cross-lane deactivation (RFC 0159 §A.3 — opt-in)
     if (!idpUrl || !scimUrl) return softSkip('inapplicable', 'opt-in: SAML IdP and/or SCIM endpoint not provided');
 
     // 1. Provision a SCIM user carrying an opaque, IdP-stable externalId.
-    const externalId = 'idp-op-8f3a';
+    //
+    // MINTED PER EXERCISE (2.37.0). This was the literal `'idp-op-8f3a'`, and
+    // the SCIM directory it is provisioned into is the OPERATOR's
+    // (`OPENWOP_TEST_SCIM_URL`) — durable state outside this process. Step 3
+    // DEACTIVATES that user, and deactivation is the whole point of the leg, so
+    // the second run of this file against the same directory provisions an
+    // externalId that is already present and already deactivated. Step 2 then
+    // asserts "a valid linked SAML assertion authenticates before deactivation"
+    // against a subject the host is CORRECT to refuse: cold directory passes,
+    // warm directory fails, nothing about the host having changed. Same shape as
+    // the shared effect identity in `lib/effect-receiver.ts` (openwop#1513) and
+    // the fixed trigger-bridge dedup key.
+    //
+    // Unwitnessed: both opt-in variables are unset in every cut this suite has
+    // run, so the leg has never executed and the collision has never fired. It
+    // is read off the code, and the fix costs nothing if the reading is wrong.
+    const externalId = `idp-op-${randomBytes(6).toString('hex')}`;
     const provision = await driver.post('/v1/host/sample/auth/scim/provision', {
       scimUrl,
       op: 'create-user',

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/trigger-bridge-delivery.test.ts

@@ -38,6 +38,7 @@ import {
 } from '../lib/triggerBridge.js';
 import { queryTestEvents, requireEvents, isEventLogSeamAvailable, resetTestSeam } from '../lib/event-log-query.js';
 import { req } from '../lib/requirement-ids.js';
+import { freshDedupKey } from '../lib/triggerBridge.js';
 
 const CONTENT_FREE_FORBIDDEN = ['body', 'headers', 'payload', 'secret', 'credentials', 'token', 'apiKey'];
 
@@ -56,7 +57,21 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
     if (!(await isEventLogSeamAvailable())) return seamAbsent('host advertises openwop-trigger-bridge but the event-log seam is absent');
 
     // ---- Leg 1: dedup → effectively-once (§C-1) ---------------------------
-    const dedup = await driveDelivery({ scenario: 'dedup', dedupKey: 'conformance-dedup-key', source: 'queue' });
+    //
+    // The dedupKey is MINTED PER EXERCISE, and that is load-bearing (2.37.0).
+    // It used to be the literal `'conformance-dedup-key'`, and §C-1's dedup
+    // window is a ≥24h FLOOR — so the second run of this file against the same
+    // host, any time that day, hands the bridge a key it has already delivered.
+    // A CONFORMANT host then collapses the whole exercise into the first run's
+    // outcome and emits ZERO `delivered` attempts under this run's id, and the
+    // `=== 1` below convicts it. Cold host passes, warm host fails, nothing
+    // about the host having changed — the same shape as the RFC 0158 row that
+    // shared one effect identity between two files (`lib/effect-receiver.ts`).
+    // The REPETITION that §C-1 is about happens INSIDE `driveDelivery`'s
+    // `scenario: 'dedup'`, so a fresh key per exercise removes the cross-run
+    // collision without weakening the clause.
+    const dedupKey = freshDedupKey('queue');
+    const dedup = await driveDelivery({ scenario: 'dedup', dedupKey, source: 'queue' });
     if (dedup === null) return seamAbsent('host advertises openwop-trigger-bridge but the delivery seam is unwired');
 
     // The profile is derived AND the seam is wired — missing evidence is a
@@ -68,7 +83,7 @@ describe('trigger-bridge-delivery (RFC 0083 §C)', () => {
       'trigger.delivery.attempted (dedup)',
     );
     const deliveredForKey = dedupEvents.filter(
-      (e) => e.payload.dedupKey === 'conformance-dedup-key' && e.payload.outcome === 'delivered',
+      (e) => e.payload.dedupKey === dedupKey && e.payload.outcome === 'delivered',
     );
     expect(
       deliveredForKey.length === 1,

package/src/scenarios/trigger-stream-cdc-sources.test.ts

@@ -47,7 +47,7 @@ import { SCHEMAS_DIR, FIXTURES_DIR } from '../lib/paths.js';
 import { driver } from '../lib/driver.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
-import { driveDelivery } from '../lib/triggerBridge.js';
+import { driveDelivery, freshStreamDedupKey } from '../lib/triggerBridge.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip } from '../lib/soft-skip.js';
 
@@ -203,7 +203,22 @@ describe.skipIf(HTTP_SKIP)('trigger-stream-cdc: behavioral ingestion + dedup (ca
     const external = tb?.ingestion?.externalSources ?? [];
     if (!behaviorGate('triggerBridge.ingestion', (external.length ?? 0) > 0)) return;
 
-    const first = await driveDelivery({ scenario: 'dedup', dedupKey: 'events:3:99001', source: 'stream' });
+    // The broker coordinates are MINTED PER EXERCISE (2.37.x), and that is
+    // load-bearing. This was the literal `'events:3:99001'`, and §F.5 reuses
+    // §C-1's dedup window — a ≥24h FLOOR — verbatim, so the second run of this
+    // file against the same host, any time that day, hands the bridge an offset
+    // it has already delivered. A CONFORMANT host then collapses the exercise
+    // into the first run's outcome and reports neither a `deliveredCount` of 1
+    // nor `outcome: 'delivered'` under this run, and the assertion below
+    // convicts it: cold host passes, warm host fails, nothing about the host
+    // having changed. The repetition §C-1 is about happens INSIDE the seam's
+    // `scenario: 'dedup'` (it delivers the key TWICE), so a fresh offset per
+    // exercise removes the cross-run collision without weakening the clause.
+    // Same defect and same fix as `trigger-bridge-delivery`'s dedup key; the
+    // offset rather than an opaque token, because the `(topic,partition,offset)`
+    // keying is what the `req()` message below asserts over.
+    const dedupKey = freshStreamDedupKey();
+    const first = await driveDelivery({ scenario: 'dedup', dedupKey, source: 'stream' });
     if (first === null) return softSkip('blocked', 'precondition not met — `first === null` returned early (delivery seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // delivery seam unwired — soft-skip
     if (first.outcome === undefined && !external.includes('stream')) return softSkip('blocked', 'precondition not met — `first.outcome === undefined && !external.includes(\'stream\')` returned early (pre-0127 host — soft-skip) (seam, prior step, or fixture unavailable)'); // pre-0127 host — soft-skip
     expect(

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);