@openwop/openwop-conformance 2.0.4 → 2.0.6

package/src/scenarios/v2-unmapped-type-refused.test.ts

@@ -11,9 +11,27 @@
  *
  * An era-2 log carrying one `foo.bar` row is seeded through the event-log seed
  * seam (lib/era2-seed.ts); the read is driven through poll and, where `replay`
- * is advertised, through a fork. A vendor-prefixed control (read under its own
- * name) needs an org registered under `extensions` in `spec/v2/declaration.json`
- * that the suite does not own, so that half is not driven.
+ * is advertised, through a fork.
+ *
+ * THE CONTROL, and why it was missing. Until this revision only the REFUSAL
+ * half was driven, and a host that refuses EVERY type the codemap does not name
+ * — including a registered vendor type it is required to pass through — went
+ * green on the whole file while violating `persistence.md` §The codemap is data.
+ * A one-sided rule is not witnessed by its own negative case. The positive half
+ * needs an org registered in the `extensions` object of `spec/v2/declaration.json`
+ * that no host owns; the registry did not exist, so the suite could not drive
+ * it and this docblock recorded the gap instead of closing it. `extensions` now
+ * exists and holds `example`, reserved by the protocol and never assignable to
+ * a vendor (RFC 2606 precedent), so `example.thing-happened` is a type that is
+ * registered, unmapped, and owned by nobody — exactly the control this file
+ * lacked. The two legs are each other's non-vacuity check: refusing both is a
+ * defect, accepting both is a defect, and only the pair can tell them apart.
+ *
+ * BECAUSE THEY CHECK OPPOSITE HALVES, THEY GATE SEPARATELY (`refusalGate` /
+ * `controlGate`). Suite 2.0.5 gated both on the control leg's precondition and
+ * so disabled the refusal witness wherever the registry did not resolve — on
+ * exactly the hosts it exists to catch. A precondition belongs to the leg that
+ * needs it, never to the file.
  *
  * @see spec/v2/core/persistence.md §The reader rule
  * @see spec/v2/core/events.md §Reading an era-2 log
@@ -24,11 +42,26 @@ import { v2Discovery, gateFamily } from '../lib/v2.js';
 import { readErrorCode, readRetriable } from '../lib/error-envelope.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
-import { era2Gate, eventsOf, forkRun, pollEvents, seedEra2Log, type SeedEvent } from '../lib/era2-seed.js';
+import { codemapV1toV2, era2Gate, eventsOf, forkRun, pollEvents, registeredOrgs, seedEra2Log, unmappedRefusalGate, vendorControlGate, type Gate, type SeedEvent } from '../lib/era2-seed.js';
 
 const DOC = 'spec/v2/core/persistence.md §The reader rule';
+const MAP = 'spec/v2/core/persistence.md §The codemap is data';
 const CODE = 'event_type_unmapped';
+const ID_VENDOR = 'openwop.requirement.0176.vendor-type-passthrough';
 const UNMAPPED = 'foo.bar';
+/** Registered (`extensions` in the declaration), unmapped, owned by no host. */
+const VENDOR = 'example.thing-happened';
+
+/**
+ * The gate logic is PURE and lives in lib/era2-seed (`unmappedRefusalGate` /
+ * `vendorControlGate`) so its truth table can be measured directly — see
+ * `src/lib/era2-unmapped-gates.test.ts`. The rows that matter cannot be
+ * exercised from here: they are the layouts where the registry does NOT
+ * resolve, which is where the 2.0.5 defect lived and where a scenario running
+ * against a live host can never put itself.
+ */
+const refusalGate = (): Gate => unmappedRefusalGate(registeredOrgs(), codemapV1toV2(), UNMAPPED);
+const controlGate = (): Gate => vendorControlGate(registeredOrgs(), codemapV1toV2(), VENDOR);
 
 async function discovery(): Promise<Record<string, unknown> | null> {
   try { return await v2Discovery(); } catch { return null; }
@@ -39,7 +72,18 @@ function unmappedLog(): SeedEvent[] {
   const ts = (i: number) => new Date(t0 + i * 1000).toISOString();
   return [
     { type: 'run.started', sequence: 0, payload: { workflowId: 'conformance-noop' }, timestamp: ts(0) },
-    { type: UNMAPPED, sequence: 1, payload: { note: 'not a codemap row, not a vendor org' }, timestamp: ts(1) },
+    { type: UNMAPPED, sequence: 1, payload: {}, timestamp: ts(1) },
+    { type: 'run.completed', sequence: 2, payload: { durationMs: 2000 }, timestamp: ts(2) },
+  ];
+}
+
+/** The same shape carrying a REGISTERED vendor type instead of an unmapped one. */
+function vendorLog(): SeedEvent[] {
+  const t0 = Date.parse('2026-01-15T12:00:00.000Z');
+  const ts = (i: number) => new Date(t0 + i * 1000).toISOString();
+  return [
+    { type: 'run.started', sequence: 0, payload: { workflowId: 'conformance-noop' }, timestamp: ts(0) },
+    { type: VENDOR, sequence: 1, payload: { marker: 'era2-vendor-passthrough' }, timestamp: ts(1) },
     { type: 'run.completed', sequence: 2, payload: { durationMs: 2000 }, timestamp: ts(2) },
   ];
 }
@@ -50,6 +94,8 @@ describe('RFC 0176 §A.3 — unmapped-type-refused (seam-gated)', () => {
     if (!doc) return softSkip('blocked', 'discovery unreachable');
     const gate = era2Gate(doc);
     if (gate !== null && !gate.ok) return softSkip(gate.kind, gate.reason);
+    const pre = refusalGate();
+    if (!pre.ok) return softSkip(pre.kind, pre.reason);
     const seeded = await seedEra2Log(unmappedLog(), 'completed');
     if (!seeded.ok) return softSkip(seeded.kind, seeded.reason);
     const res = await pollEvents(seeded.runId);
@@ -68,12 +114,41 @@ describe('RFC 0176 §A.3 — unmapped-type-refused (seam-gated)', () => {
     ).toBe(false);
   });
 
+  it('a REGISTERED vendor type the codemap does not name is read under its own name, unchanged', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'discovery unreachable');
+    const gate = era2Gate(doc);
+    if (gate !== null && !gate.ok) return softSkip(gate.kind, gate.reason);
+    const pre = controlGate();
+    if (!pre.ok) return softSkip(pre.kind, pre.reason);
+    const seeded = await seedEra2Log(vendorLog(), 'completed');
+    if (!seeded.ok) return softSkip(seeded.kind, seeded.reason);
+    const res = await pollEvents(seeded.runId);
+    if (res === null) return softSkip('blocked', 'GET /runs/{runId}/events/poll unreachable (fetch failed)');
+    // The whole point of the control: this is the SAME log shape as the refusal
+    // leg with one segment changed, so a 500 here says the host is refusing on
+    // "not in the codemap" and not on "not a registered org" — the tolerant
+    // reader's mirror image, and just as wrong.
+    expect(
+      res.status,
+      req(ID_VENDOR, MAP, `a vendor-prefixed type whose org IS registered MUST be read under its own name unchanged, not refused — got ${res.status}${res.status === 500 ? ` ${readErrorCode(res.json) ?? ''}: the host refuses every type the codemap does not name, which fails the registered half of the rule` : ''}`.trim()),
+    ).toBe(200);
+    const types = eventsOf(res.json).map((e) => String(e.type));
+    expect(
+      types.includes(VENDOR),
+      req(ID_VENDOR, MAP, `the ${VENDOR} row MUST appear under its own name — read back [${types.join(', ')}]; a translated or dropped row is a private mapping, and the codemap is the only authority`),
+    ).toBe(true);
+  });
+
   it('a fork of the same log is refused for the same reason — the rule binds every reader', async () => {
     const doc = await discovery();
     if (!doc) return softSkip('blocked', 'discovery unreachable');
     const gate = era2Gate(doc);
     if (gate !== null && !gate.ok) return softSkip(gate.kind, gate.reason);
     if (!(await gateFamily('replay'))) return softSkip('inapplicable', 'replay family not advertised (gate recorded under openwop.family.replay) — the fork reader has no surface');
+    // The fork leg drives the UNMAPPED type, so it takes the refusal gate.
+    const pre = refusalGate();
+    if (!pre.ok) return softSkip(pre.kind, pre.reason);
     const log = unmappedLog();
     const seeded = await seedEra2Log(log, 'completed');
     if (!seeded.ok) return softSkip(seeded.kind, seeded.reason);