@openwop/openwop-conformance 1.152.0 → 1.154.0

package/src/scenarios/normative-example-extraction.test.ts

@@ -1,242 +0,0 @@
-/**
- * RFC 0149 §D — normative examples are extracted and validated against the
- * same schemas conformance uses.
- *
- * "Normative examples MUST be extracted into fixtures and validated against
- * the same schemas used by conformance" (§D). Until now a fenced example was
- * prose to every validator in the corpus: `capability-example-root-layout`
- * catches one wrong SHAPE (the `capabilities` wrapper), but an example could
- * carry a misspelled field, a wrong enum value, or a stale required property
- * and every gate stayed green — a green corpus teaching a non-conformant
- * document.
- *
- * Mechanism — a declaration, not a heuristic:
- *
- *   <!-- normative-example: <name>.schema.json -->
- *   ```json
- *   { ... }
- *   ```
- *
- * The HTML comment on the line immediately before a ```json / ```jsonc fence
- * declares that the fenced body is a WHOLE instance of the named schema. The
- * scenario extracts each declared example at test time and validates it with
- * Ajv against `schemas/<name>` — the identical schema files and registration
- * (`fixtures-valid.test.ts` enumerates the directory the same way) that every
- * other conformance leg uses. Extraction is in-process rather than committed
- * under `fixtures/`: a committed copy of a prose example is a second source
- * of truth that drifts, which is the defect §D exists to remove.
- *
- * Non-vacuity guards (RFC 0148 §A — an extractor that matches nothing must
- * not pass):
- *   - the corpus MUST contain declared examples (floor asserted);
- *   - every fenced JSON block in spec/v1 that parses and validates as a whole
- *     instance of some non-permissive schema MUST be declared — an example
- *     that IS a schema instance is a normative example, and the marker is how
- *     it says so; a new whole-document example added without the marker fails
- *     here rather than silently escaping validation;
- *   - every declared example MUST parse as strict JSON (jsonc comments and
- *     ellipses are prose, not instances) and MUST validate;
- *   - every discovery-shaped example (root `protocolVersion` +
- *     `supportedEnvelopes`) MUST be declared against `capabilities.schema.json`
- *     ("all normative discovery examples ... validate" — RFC 0149 acceptance);
- *   - §E: no declared discovery example carries credential- or tenant-shaped
- *     keys.
- *
- * Server-free; always-on in the corpus layout (spec prose is not shipped in the
- * published package, so `V1_DIR === null` skips the describe there).
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import Ajv2020 from 'ajv/dist/2020.js';
-import addFormats from 'ajv-formats';
-import type { ValidateFunction } from 'ajv';
-import { SCHEMAS_DIR, V1_DIR } from '../lib/paths.js';
-
-export const HOST_CALLBACK_NOT_REQUIRED = 'server-free: extracts fenced prose examples and validates them against the schema files on disk; no host is contacted';
-
-const MARKER = /^<!--\s*normative-example:\s*([a-z0-9-]+\.schema\.json)\s*-->\s*$/;
-
-interface Fenced {
-  readonly file: string;
-  /** 1-based line of the ``` opener. */
-  readonly line: number;
-  readonly info: string;
-  readonly body: string;
-  /** Schema declared by a marker on the preceding line, if any. */
-  readonly declared: string | null;
-}
-
-function fencedBlocks(dir: string): Fenced[] {
-  const out: Fenced[] = [];
-  for (const name of readdirSync(dir).filter((f) => f.endsWith('.md')).sort()) {
-    const lines = readFileSync(join(dir, name), 'utf8').split('\n');
-    for (let i = 0; i < lines.length; i++) {
-      const open = /^```(json|jsonc)(\s.*)?$/.exec(lines[i]!.trim());
-      if (open === null) continue;
-      const body: string[] = [];
-      let j = i + 1;
-      while (j < lines.length && lines[j]!.trim() !== '```') {
-        body.push(lines[j]!);
-        j++;
-      }
-      const prev = i > 0 ? (lines[i - 1] ?? '') : '';
-      const m = MARKER.exec(prev.trim());
-      out.push({ file: name, line: i + 1, info: open[1] ?? 'json', body: body.join('\n'), declared: m?.[1] ?? null });
-      i = j;
-    }
-  }
-  return out;
-}
-
-/** Stray markers: a marker line NOT immediately followed by a fence opener. */
-function strayMarkers(dir: string): string[] {
-  const out: string[] = [];
-  for (const name of readdirSync(dir).filter((f) => f.endsWith('.md')).sort()) {
-    const lines = readFileSync(join(dir, name), 'utf8').split('\n');
-    for (let i = 0; i < lines.length; i++) {
-      if (!MARKER.test(lines[i]!.trim())) continue;
-      const next = (lines[i + 1] ?? '').trim();
-      if (!/^```(json|jsonc)(\s|$)/.test(next)) out.push(`spec/v1/${name}:${i + 1}`);
-    }
-  }
-  return out;
-}
-
-function parseStrict(body: string): unknown | undefined {
-  try {
-    return JSON.parse(body) as unknown;
-  } catch {
-    return undefined;
-  }
-}
-
-function isDiscoveryShaped(v: unknown): boolean {
-  return (
-    v !== null &&
-    typeof v === 'object' &&
-    !Array.isArray(v) &&
-    typeof (v as Record<string, unknown>)['protocolVersion'] === 'string' &&
-    Array.isArray((v as Record<string, unknown>)['supportedEnvelopes'])
-  );
-}
-
-/** Register every schema in the directory (S14 pattern) and hand back validators by file name. */
-function validators(): { byFile: Map<string, ValidateFunction>; permissive: Set<string> } {
-  const ajv = new Ajv2020({ allErrors: true, strict: false });
-  addFormats(ajv);
-  const files = readdirSync(SCHEMAS_DIR).filter((f) => f.endsWith('.schema.json')).sort();
-  const docs = new Map<string, { $id?: string }>();
-  for (const f of files) {
-    const doc = JSON.parse(readFileSync(join(SCHEMAS_DIR, f), 'utf8')) as { $id?: string };
-    docs.set(f, doc);
-    ajv.addSchema(doc);
-  }
-  const byFile = new Map<string, ValidateFunction>();
-  for (const [f, doc] of docs) {
-    const v = doc.$id === undefined ? undefined : ajv.getSchema(doc.$id);
-    if (v !== undefined) byFile.set(f, v);
-  }
-  // A schema that accepts `{}` AND `{x:1}` constrains nothing at the root; a
-  // whole-document match against it says nothing about the example, so it is
-  // excluded from the "must be declared" auto-detection (still usable as an
-  // explicit declaration).
-  const permissive = new Set([...byFile.entries()].filter(([, v]) => v({}) === true && v({ x: 1 }) === true).map(([f]) => f));
-  return { byFile, permissive };
-}
-
-const CREDENTIAL_KEY = /^(apiKey|api_key|token|accessToken|refreshToken|secret|clientSecret|password|authorization|bearer|tenantId|tenant_id|organizationId)$/i;
-function credentialShapedKeys(v: unknown, path = '$'): string[] {
-  const out: string[] = [];
-  if (Array.isArray(v)) {
-    v.forEach((x, i) => out.push(...credentialShapedKeys(x, `${path}[${i}]`)));
-  } else if (v !== null && typeof v === 'object') {
-    for (const [k, x] of Object.entries(v as Record<string, unknown>)) {
-      if (CREDENTIAL_KEY.test(k)) out.push(`${path}.${k}`);
-      out.push(...credentialShapedKeys(x, `${path}.${k}`));
-    }
-  }
-  return out;
-}
-
-describe.skipIf(V1_DIR === null)('RFC 0149 §D — normative examples are extracted and validated against the conformance schemas', () => {
-  // `describe.skipIf` still RUNS this factory in the published layout (vitest
-  // collects skipped suites), so nothing here may touch the prose directory
-  // when it is absent — the guards below keep collection green in the tarball.
-  const v1Dir = V1_DIR ?? '';
-  const blocks = V1_DIR === null ? [] : fencedBlocks(v1Dir);
-  const declared = blocks.filter((b) => b.declared !== null);
-  const { byFile, permissive } = V1_DIR === null ? { byFile: new Map<string, ValidateFunction>(), permissive: new Set<string>() } : validators();
-
-  it('the extractor finds fenced examples and the corpus declares normative ones (non-vacuity floor)', () => {
-    expect(blocks.length, 'spec/v1 MUST contain fenced json/jsonc examples').toBeGreaterThan(100);
-    expect(declared.length, 'spec/v1 MUST declare normative examples with <!-- normative-example: … -->').toBeGreaterThanOrEqual(20);
-    expect(byFile.size, 'schemas/ MUST register').toBeGreaterThan(50);
-  });
-
-  it('every marker names a schema that exists and sits immediately above a json/jsonc fence', () => {
-    const unknown = declared.filter((b) => !byFile.has(b.declared as string)).map((b) => `spec/v1/${b.file}:${b.line} → ${String(b.declared)}`);
-    expect(unknown, 'normative-example markers naming a schema that does not exist in schemas/').toEqual([]);
-    expect(strayMarkers(v1Dir), 'normative-example markers not directly followed by a ```json fence').toEqual([]);
-  });
-
-  it('every declared example parses as strict JSON — jsonc comments and ellipses are prose, not instances', () => {
-    const unparsable = declared.filter((b) => parseStrict(b.body) === undefined).map((b) => `spec/v1/${b.file}:${b.line} (${b.info}) declared ${String(b.declared)}`);
-    expect(unparsable, 'declared normative examples MUST be strict JSON').toEqual([]);
-  });
-
-  it('every declared example VALIDATES against its declared schema — the same schema file conformance uses', () => {
-    const failures: string[] = [];
-    for (const b of declared) {
-      const doc = parseStrict(b.body);
-      if (doc === undefined) continue; // reported by the leg above
-      const v = byFile.get(b.declared as string);
-      if (v === undefined) continue; // reported by the leg above
-      if (v(doc) !== true) {
-        const errs = (v.errors ?? []).slice(0, 3).map((e) => `${e.instancePath || '/'} ${e.message ?? ''}`).join('; ');
-        failures.push(`spec/v1/${b.file}:${b.line} ✗ ${String(b.declared)}: ${errs}`);
-      }
-    }
-    expect(failures, 'RFC 0149 §D: a normative example that does not validate teaches a non-conformant document').toEqual([]);
-  });
-
-  it('every fenced JSON block that IS a whole instance of a (non-permissive) schema is declared — no undeclared normative example', () => {
-    const undeclared: string[] = [];
-    for (const b of blocks) {
-      if (b.declared !== null) continue;
-      const doc = parseStrict(b.body);
-      if (doc === undefined) continue;
-      const hits = [...byFile.entries()].filter(([f, v]) => !permissive.has(f) && v(doc) === true).map(([f]) => f);
-      if (hits.length > 0) undeclared.push(`spec/v1/${b.file}:${b.line} validates as ${hits.join(' | ')} — add <!-- normative-example: <one of these> --> above the fence`);
-    }
-    expect(undeclared, 'whole-document examples MUST be declared so they are validated on every run').toEqual([]);
-  });
-
-  it('every discovery-shaped example is declared against capabilities.schema.json and validates (RFC 0149: "all normative discovery examples ... validate")', () => {
-    const discovery = blocks.filter((b) => isDiscoveryShaped(parseStrict(b.body)));
-    expect(discovery.length, 'spec/v1 MUST carry at least one whole discovery example').toBeGreaterThan(0);
-    const wrong = discovery.filter((b) => b.declared !== 'capabilities.schema.json').map((b) => `spec/v1/${b.file}:${b.line} declared ${String(b.declared)}`);
-    expect(wrong, 'discovery-shaped examples MUST be declared normative-example: capabilities.schema.json').toEqual([]);
-    const v = byFile.get('capabilities.schema.json');
-    expect(v).toBeDefined();
-    for (const b of discovery) expect((v as ValidateFunction)(parseStrict(b.body)), `spec/v1/${b.file}:${b.line}`).toBe(true);
-  });
-
-  it('§E: no declared discovery example carries credential- or tenant-shaped keys', () => {
-    const offenders: string[] = [];
-    for (const b of declared.filter((x) => x.declared === 'capabilities.schema.json')) {
-      for (const p of credentialShapedKeys(parseStrict(b.body))) offenders.push(`spec/v1/${b.file}:${b.line} ${p}`);
-    }
-    expect(offenders, 'RFC 0149 §E: no discovery example may contain credentials or tenant data').toEqual([]);
-  });
-
-  it('sabotage: a declared example with a wrong enum value is caught by the same validator path', () => {
-    // Guard against a validator that compiles to `true` (strict:false + a
-    // schema that failed to register would do that silently).
-    const v = byFile.get('error-envelope.schema.json');
-    expect(v).toBeDefined();
-    expect((v as ValidateFunction)({ error: 'not_found', message: 'gone', retriable: 'yes' })).toBe(false);
-    expect((v as ValidateFunction)({ error: 'not_found', message: 'gone' })).toBe(true);
-  });
-});

package/src/scenarios/openapi-asyncapi-sdk-parity.test.ts

@@ -1,309 +0,0 @@
-/**
- * RFC 0149 §A / §Conformance — `openapi-asyncapi-sdk-parity`.
- *
- * "SDK operation URLs and AsyncAPI bindings MUST match the resolved OpenAPI
- * path" (§A), and "SDK repositories consume a generated canonical
- * operation-path manifest" (§Conformance). `openapi-resolved-paths.test.ts`
- * landed the OpenAPI half (exactly one `/v1` per resolved operation); this
- * scenario lands the AsyncAPI half and the manifest, and witnesses the SDK
- * half when the SDK repository is reachable.
- *
- * Legs:
- *   1. `spec/v1/operation-path-manifest.json` — the canonical resolved
- *      operation-path manifest — is in sync with `api/openapi.yaml`: this file
- *      re-derives the rows from the contract with its own scanner and compares,
- *      so the generator (`scripts/generate-operation-path-manifest.mjs`) and
- *      the suite cannot silently disagree; every row carries exactly one `/v1`
- *      (none for `/.well-known/*`); the digest matches the body.
- *   2. AsyncAPI bindings: every channel `address` (resolved under
- *      `servers.*.pathname`) is an OpenAPI path key with a GET operation, with
- *      exactly one `/v1`; the AsyncAPI server pathname carries the version
- *      segment exactly once. The AsyncAPI document names the same wire
- *      the OpenAPI document does — no second contract for the event stream.
- *   3. SDK parity (`openwop-sdks`): the SDK repository's
- *      `sdk/parity-expectations.json` covers every CANONICAL manifest
- *      operation with the same method + resolved path, declares no operation
- *      the manifest lacks, and the TypeScript client issues every path an
- *      operation declared `ts: typed` names. Reached through
- *      `OPENWOP_SDKS_DIR` or the sibling checkout `../openwop-sdks`. When the
- *      SDK tree is NOT reachable the requirement is recorded `blocked` with the
- *      reason — RFC 0148 §A: an unwitnessed requirement is blocked, never a
- *      pass — and the leg returns without asserting.
- *
- * Server-free (reads files only). Legs 1–2 always-on.
- */
-
-import { describe, it, expect } from 'vitest';
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { createHash } from 'node:crypto';
-import { join, resolve } from 'node:path';
-import { API_DIR, V1_DIR } from '../lib/paths.js';
-import { recordRequirement } from '../lib/requirement-ledger.js';
-
-export const HOST_CALLBACK_NOT_REQUIRED = 'server-free: compares contract documents and (when reachable) SDK sources on disk; no host is contacted';
-
-/** RFC 0148 §A requirement id for the SDK half, recorded blocked when unwitnessable. */
-export const SDK_PATH_PARITY_REQUIREMENT = 'openwop.requirement.rfc0149.sdk-path-parity';
-
-const OPENAPI = readFileSync(join(API_DIR, 'openapi.yaml'), 'utf8');
-const ASYNCAPI = readFileSync(join(API_DIR, 'asyncapi.yaml'), 'utf8');
-const MANIFEST_PATH = V1_DIR === null ? null : join(V1_DIR, 'operation-path-manifest.json');
-
-const VERBS = new Set(['get', 'post', 'put', 'patch', 'delete', 'head', 'options']);
-
-interface Op { operationId: string | null; method: string; pathKey: string; tag: string | null }
-interface Row { operationId: string; method: string; pathKey: string; resolvedPath: string; tag: string; class: string }
-
-function serverUrls(raw: string): string[] {
-  const urls: string[] = [];
-  let inServers = false;
-  for (const line of raw.split('\n')) {
-    if (/^servers:/.test(line)) { inServers = true; continue; }
-    if (inServers && /^[^\s#]/.test(line)) break;
-    if (!inServers) continue;
-    const m = /^\s*-\s*url:\s*(\S+)\s*$/.exec(line);
-    if (m?.[1] !== undefined) urls.push(m[1]);
-  }
-  return urls;
-}
-function resolvedPath(serverUrl: string, pathKey: string): string {
-  const afterScheme = serverUrl.replace(/^[a-z][a-z0-9+.-]*:\/\//i, '');
-  const slash = afterScheme.indexOf('/');
-  const basePath = slash === -1 ? '' : afterScheme.slice(slash);
-  return `${basePath.replace(/\/$/, '')}${pathKey}`;
-}
-function operations(raw: string): Op[] {
-  const rows: Op[] = [];
-  let inPaths = false;
-  let pathKey: string | null = null;
-  let op: Op | null = null;
-  for (const line of raw.split('\n')) {
-    if (/^paths:/.test(line)) { inPaths = true; continue; }
-    if (inPaths && /^[^\s#]/.test(line)) break;
-    if (!inPaths) continue;
-    const p = /^ {2}(\/\S*):\s*$/.exec(line);
-    if (p?.[1] !== undefined) { pathKey = p[1]; op = null; continue; }
-    const v = /^ {4}([a-z]+):\s*$/.exec(line);
-    if (v?.[1] !== undefined && VERBS.has(v[1]) && pathKey !== null) {
-      op = { operationId: null, method: v[1].toUpperCase(), pathKey, tag: null };
-      rows.push(op);
-      continue;
-    }
-    if (op === null) continue;
-    const id = /^ {6}operationId:\s*([A-Za-z0-9_]+)\s*$/.exec(line);
-    if (id?.[1] !== undefined) { op.operationId = id[1]; continue; }
-    const t = /^ {6}tags:\s*\[([^\]]*)\]\s*$/.exec(line);
-    if (t?.[1] !== undefined) { op.tag = (t[1].split(',')[0] ?? '').trim(); continue; }
-  }
-  return rows;
-}
-function classify(tag: string | null): string {
-  if (tag === 'host') return 'host-extension';
-  if (tag === 'packs-test') return 'test-catalog';
-  return 'canonical';
-}
-function deriveRows(): { serverUrl: string; rows: Row[] } {
-  const servers = serverUrls(OPENAPI);
-  const base = servers[0] ?? '';
-  const rows: Row[] = operations(OPENAPI).map((o) => ({
-    operationId: o.operationId ?? '',
-    method: o.method,
-    pathKey: o.pathKey,
-    resolvedPath: resolvedPath(base, o.pathKey),
-    tag: o.tag ?? '',
-    class: classify(o.tag),
-  }));
-  rows.sort((a, b) => a.resolvedPath.localeCompare(b.resolvedPath) || a.method.localeCompare(b.method));
-  return { serverUrl: base, rows };
-}
-function v1Segments(p: string): number {
-  return (p.match(/\/v1(?=\/|$)/g) ?? []).length;
-}
-
-/* ─── AsyncAPI scanning ─────────────────────────────────────────────────── */
-
-function asyncapiServerPathnames(raw: string): string[] {
-  const out: string[] = [];
-  let inServers = false;
-  for (const line of raw.split('\n')) {
-    if (/^servers:/.test(line)) { inServers = true; continue; }
-    if (inServers && /^[^\s#]/.test(line)) break;
-    if (!inServers) continue;
-    const m = /^\s+pathname:\s*(\S+)\s*$/.exec(line);
-    if (m?.[1] !== undefined) out.push(m[1]);
-  }
-  return out;
-}
-/** Channel `address:` values (a `null` address is a logical channel and is skipped). */
-function asyncapiChannelAddresses(raw: string): { channel: string; address: string | null }[] {
-  const out: { channel: string; address: string | null }[] = [];
-  let inChannels = false;
-  let channel: string | null = null;
-  for (const line of raw.split('\n')) {
-    if (/^channels:/.test(line)) { inChannels = true; continue; }
-    if (inChannels && /^[^\s#]/.test(line)) break;
-    if (!inChannels) continue;
-    const c = /^ {2}([A-Za-z][\w.-]*):\s*$/.exec(line);
-    if (c?.[1] !== undefined) { channel = c[1]; continue; }
-    const a = /^ {4}address:\s*(\S+)\s*$/.exec(line);
-    if (a?.[1] !== undefined && channel !== null) out.push({ channel, address: a[1] === 'null' ? null : a[1] });
-  }
-  return out;
-}
-
-/* ─── SDK repository probing ────────────────────────────────────────────── */
-
-function sdksDir(): string | null {
-  const env = process.env['OPENWOP_SDKS_DIR'];
-  if (env !== undefined && env !== '' && existsSync(join(env, 'sdk', 'parity-expectations.json'))) return resolve(env);
-  if (V1_DIR === null) return null;
-  const sibling = resolve(V1_DIR, '..', '..', '..', 'openwop-sdks');
-  return existsSync(join(sibling, 'sdk', 'parity-expectations.json')) ? sibling : null;
-}
-function collectTs(dir: string): string {
-  let out = '';
-  for (const name of readdirSync(dir)) {
-    const p = join(dir, name);
-    if (statSync(p).isDirectory()) { if (!/node_modules|__tests__/.test(name)) out += collectTs(p); continue; }
-    if (name.endsWith('.ts') && !/\.test\./.test(name)) out += readFileSync(p, 'utf8') + '\n';
-  }
-  return out;
-}
-/**
- * The most distinctive STATIC fragment of a templated path: everything up to
- * the first `{param}` (an SDK builds the rest with `encodeURIComponent`).
- * `/v1/runs/{runId}:fork` → `/v1/runs/` … plus the tail `:fork` checked
- * separately when the template ends in a static suffix.
- */
-function staticFragments(pathTpl: string): string[] {
-  const head = pathTpl.split('{')[0] ?? pathTpl;
-  const tail = /\}([^{}]*)$/.exec(pathTpl)?.[1] ?? '';
-  const frags = [head];
-  if (tail !== '' && tail !== '/') frags.push(tail);
-  return frags;
-}
-
-describe('RFC 0149 §A/§Conformance — the canonical operation-path manifest is in sync with the contract', () => {
-  it('spec/v1/operation-path-manifest.json exists in the corpus layout and re-derives byte-for-byte from api/openapi.yaml', () => {
-    if (MANIFEST_PATH === null) return; // published tarball: prose dir absent (see leg below)
-    expect(existsSync(MANIFEST_PATH), 'RFC 0149 §Conformance: the manifest MUST be published (run scripts/generate-operation-path-manifest.mjs --write)').toBe(true);
-    const doc = JSON.parse(readFileSync(MANIFEST_PATH, 'utf8')) as { serverUrl: string; operations: Row[]; digest: string; counts: Record<string, number> } & Record<string, unknown>;
-    const { serverUrl, rows } = deriveRows();
-    expect(doc.serverUrl).toBe(serverUrl);
-    expect(doc.operations).toEqual(rows);
-    expect(doc.counts['total']).toBe(rows.length);
-    const { digest: _d, ...body } = doc;
-    expect(doc.digest).toBe(createHash('sha256').update(JSON.stringify(body), 'utf8').digest('hex'));
-  });
-
-  it('every operation resolves to exactly one /v1 segment (none for /.well-known/*), has an operationId, and ids are unique', () => {
-    const { rows } = deriveRows();
-    expect(rows.length).toBeGreaterThan(40);
-    const ids = new Set<string>();
-    for (const r of rows) {
-      expect(r.operationId, `${r.method} ${r.pathKey} has no operationId`).not.toBe('');
-      expect(ids.has(r.operationId), `duplicate operationId ${r.operationId}`).toBe(false);
-      ids.add(r.operationId);
-      const n = v1Segments(r.resolvedPath);
-      if (r.pathKey.startsWith('/.well-known/')) expect(n, `${r.resolvedPath} MUST be unversioned`).toBe(0);
-      else expect(n, `${r.operationId} resolves to ${r.resolvedPath}`).toBe(1);
-    }
-    // the classes are exhaustive and the canonical set is the large majority
-    expect(rows.every((r) => ['canonical', 'host-extension', 'test-catalog'].includes(r.class))).toBe(true);
-    expect(rows.filter((r) => r.class === 'canonical').length).toBeGreaterThan(rows.length / 2);
-  });
-});
-
-describe('RFC 0149 §A — AsyncAPI bindings name the same wire the OpenAPI document does', () => {
-  it('the AsyncAPI server pathname carries the version segment exactly once', () => {
-    const pathnames = asyncapiServerPathnames(ASYNCAPI);
-    expect(pathnames.length).toBeGreaterThan(0);
-    for (const p of pathnames) expect(v1Segments(p), `asyncapi servers pathname ${p}`).toBe(1);
-  });
-
-  it('every addressed channel resolves (server pathname + address) to an OpenAPI path key that has a GET operation, with exactly one /v1', () => {
-    const pathnames = asyncapiServerPathnames(ASYNCAPI);
-    const channels = asyncapiChannelAddresses(ASYNCAPI);
-    const addressed = channels.filter((c) => c.address !== null);
-    expect(addressed.length, 'at least one channel is bound to a wire address').toBeGreaterThan(0);
-    const { rows } = deriveRows();
-    const getPaths = new Set(rows.filter((r) => r.method === 'GET').map((r) => r.pathKey));
-    for (const base of pathnames) {
-      for (const c of addressed) {
-        const resolved = `${base.replace(/\/$/, '')}${c.address as string}`;
-        expect(v1Segments(resolved), `channel ${c.channel} resolves to ${resolved}`).toBe(1);
-        expect(getPaths.has(resolved), `channel ${c.channel} → ${resolved} is not a GET path in api/openapi.yaml`).toBe(true);
-      }
-    }
-  });
-
-  it('logical (address: null) channels are the only ones without a wire address, and they are documented as logical', () => {
-    const channels = asyncapiChannelAddresses(ASYNCAPI);
-    const logical = channels.filter((c) => c.address === null).map((c) => c.channel);
-    // heartbeat is the known logical channel (host-capabilities.md §host.heartbeat)
-    for (const name of logical) expect(name, `logical channel ${name} must be documented as such`).toMatch(/heartbeat/i);
-  });
-});
-
-describe('RFC 0149 §A — SDK operation URLs match the resolved OpenAPI paths (openwop-sdks parity manifest)', () => {
-  it('sdk/parity-expectations.json covers every canonical operation with the same method + path, declares nothing the contract lacks, and the TypeScript client issues every ts-typed path', () => {
-    const dir = sdksDir();
-    if (dir === null) {
-      recordRequirement(
-        SDK_PATH_PARITY_REQUIREMENT,
-        'blocked',
-        'openwop-sdks is not reachable from this runner (set OPENWOP_SDKS_DIR or check the sibling repository out next to this one); the SDK half of RFC 0149 §A parity is unwitnessed here',
-      );
-      return;
-    }
-    const exp = JSON.parse(readFileSync(join(dir, 'sdk', 'parity-expectations.json'), 'utf8')) as {
-      operations: { operationId: string; method: string; path: string; ts: string; py: string; go: string; note?: string }[];
-    };
-    const { rows } = deriveRows();
-    const byId = new Map(rows.map((r) => [r.operationId, r] as const));
-    const expById = new Map(exp.operations.map((e) => [e.operationId, e] as const));
-
-    // (a) every canonical operation is declared, with the same method and RESOLVED path
-    const missing = rows.filter((r) => r.class === 'canonical' && !expById.has(r.operationId)).map((r) => r.operationId);
-    expect(missing, 'canonical operations with no SDK parity declaration').toEqual([]);
-    const drift: string[] = [];
-    for (const r of rows) {
-      const e = expById.get(r.operationId);
-      if (e === undefined) continue;
-      if (e.method.toUpperCase() !== r.method || e.path !== r.resolvedPath) drift.push(`${r.operationId}: sdk says ${e.method} ${e.path}, contract resolves ${r.method} ${r.resolvedPath}`);
-    }
-    expect(drift, 'SDK-declared operation URLs MUST match the resolved OpenAPI path (RFC 0149 §A)').toEqual([]);
-
-    // (b) nothing declared that the contract lacks (orphan drift)
-    const orphans = exp.operations.filter((e) => !byId.has(e.operationId)).map((e) => e.operationId);
-    expect(orphans, 'SDK parity entries for operationIds the contract no longer has').toEqual([]);
-
-    // (c) the TypeScript client actually issues every ts-typed path
-    const tsSrc = collectTs(join(dir, 'sdk', 'typescript', 'src'));
-    const notIssued: string[] = [];
-    for (const e of exp.operations) {
-      if (e.ts !== 'typed') continue;
-      const frags = staticFragments(e.path);
-      if (!frags.every((f) => tsSrc.includes(f))) notIssued.push(`${e.operationId} (${e.path})`);
-    }
-    expect(notIssued, 'operations declared ts-typed whose path the TypeScript client never issues').toEqual([]);
-
-    // (d) and no HOST-client-issued /v1 literal resolves outside the contract's
-    //     canonical+host set. Scoped to the OpenwopClient modules (`client.ts`,
-    //     `sse.ts`): the SDK also carries a pack-REGISTRY client
-    //     (`registry-helpers.ts` — `/v1/packs/*`, `/v1/index.json`, issued to a
-    //     registry base) and provider-shaped types (`/v1/chat/completions`, RFC
-    //     0108, issued to a provider) that are not host operations.
-    const hostClientSrc = ['client.ts', 'sse.ts']
-      .map((f) => join(dir, 'sdk', 'typescript', 'src', f))
-      .filter((f) => existsSync(f))
-      .map((f) => readFileSync(f, 'utf8'))
-      .join('\n');
-    const issued = [...hostClientSrc.matchAll(/[`'"](\/v1\/[^`'"$?]*)/g)].map((m) => (m[1] ?? '').replace(/\/$/, ''));
-    const known = new Set(rows.map((r) => r.pathKey.split('{')[0] ?? r.pathKey));
-    const unknown = [...new Set(issued)].filter((p) => ![...known].some((k) => p.startsWith(k.replace(/\/$/, ''))) && !p.startsWith('/v1/host/'));
-    expect(unknown, 'the host client issues /v1 paths the contract does not define (outside /v1/host/* extensions)').toEqual([]);
-
-    recordRequirement(SDK_PATH_PARITY_REQUIREMENT, 'executed-pass', undefined, { assertionCount: 6 });
-  });
-});