@openwop/openwop-conformance 2.45.17 → 2.45.18

package/src/scenarios/v2-run-snapshot-etag.test.ts

@@ -9,14 +9,25 @@
  *
  * The revalidation runs once per client spelling (`OpenWOP-Version: 2.0`,
  * `2`, and `2` with a wildcard Accept): a host MUST treat them alike
- * (versioning.md §1), and one public origin served 304 to the first only.
+ * (versioning.md §1), so a host that honours only the suite's own spelling
+ * cannot pass by it.
  *
  * Control: a non-matching `If-None-Match` MUST receive 200 with the body — a
  * host that answers 304 to any conditional request fails here. `headers.md`
  * scopes `If-None-Match` to the discovery document; runs.md applies it to the
  * snapshot with a MUST (finding 5, filed).
  *
+ * RFC 0235 (`runs.md` §Caching and encoding) adds four legs, shared with
+ * `v2-discovery-etag` through `lib/if-none-match-witness.ts`: the RFC 9110
+ * match (weak, list, `*`, and two negatives), a 304 carrying the ETag, a
+ * request `Cache-Control: no-cache` not suppressing evaluation, and — only on
+ * this surface — evaluation only where the answer would be 2xx: `*` or a
+ * minted tag on a run id that does not exist gets the unconditional status,
+ * never a 304 that would disclose the run. Each of them is `inapplicable` when
+ * the snapshot carries no ETag, like the base leg.
+ *
  * @see spec/v2/core/runs.md §Snapshot
+ * @see spec/v2/core/runs.md §Caching and encoding
  * @see spec/v2/core/versioning.md §1.4
  */
 
@@ -27,11 +38,17 @@ import { v2Discovery } from '../lib/v2.js';
 import { readErrorCode } from '../lib/error-envelope.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
+import { headersLeg, judgeNot2xx, matchLeg, noCacheLeg, type Get, type LegOutcome } from '../lib/if-none-match-witness.js';
 
 const ID = 'openwop.requirement.0170.run-snapshot-etag';
 const DOC = 'spec/v2/core/runs.md §Snapshot';
 const NOOP = 'conformance-noop';
-/** The client spellings a host MUST treat alike (versioning.md §1): openwop-app's public origin answered 304 to `2.0` and 200 to bare `2`. */
+const MATCH_DOC = 'spec/v2/core/runs.md §Caching and encoding';
+const ID_MATCH = 'openwop.requirement.0235.if-none-match.rfc9110-match';
+const ID_304_ETAG = 'openwop.requirement.0235.if-none-match.304-carries-etag';
+const ID_NO_CACHE = 'openwop.requirement.0235.if-none-match.no-cache-ignored';
+const ID_ONLY_2XX = 'openwop.requirement.0235.if-none-match.only-on-2xx';
+/** The client spellings a host MUST treat alike (versioning.md §1). */
 const SPELLINGS: ReadonlyArray<Readonly<Record<string, string>>> = [
   { 'OpenWOP-Version': '2.0' },
   { 'OpenWOP-Version': '2' },
@@ -92,4 +109,68 @@ describe('v2 run-snapshot-etag (runs.md §Snapshot)', () => {
     expect(miss.status, req(ID, DOC, `a non-matching If-None-Match MUST receive 200 with the body — got ${miss.status} (a host answering 304 to any conditional request is not honouring the tag)`)).toBe(200);
     expect((miss.json as { runId?: unknown } | null)?.runId, req(ID, DOC, 'the 200 body is the snapshot')).toBe(runId);
   });
+
+  /** A settled run whose snapshot carries an ETag, or the reason there is none. */
+  let settled: Promise<{ runId: string; tag: string } | { skip: 'blocked' | 'inapplicable'; reason: string }> | null = null;
+  function settledRun(): Promise<{ runId: string; tag: string } | { skip: 'blocked' | 'inapplicable'; reason: string }> {
+    settled ??= (async () => {
+      if (!(await discovery())) return { skip: 'blocked' as const, reason: 'v2 discovery unreachable' };
+      const created = await http(() => driver.post('/runs', { workflowId: NOOP }));
+      const runId = (created?.json as { runId?: unknown } | null)?.runId;
+      if (created === null || created.status !== 201 || typeof runId !== 'string') return { skip: 'blocked' as const, reason: `POST /runs answered ${created?.status ?? 'no response'} — create refused` };
+      await pollUntilTerminal(runId, { timeoutMs: scaledTimeoutMs(30_000) });
+      const ok = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}`));
+      if (ok === null || ok.status !== 200) return { skip: 'blocked' as const, reason: `GET /runs/{runId} answered ${ok?.status ?? 'no response'}` };
+      const tag = ok.headers.get('etag');
+      if (!tag) return { skip: 'inapplicable' as const, reason: 'the snapshot carries no ETag — runs.md makes it a SHOULD; the If-None-Match rules apply only when it is present' };
+      return { runId, tag };
+    })();
+    return settled;
+  }
+  const runGet = (runId: string): Get => (headers) => http(() => driver.get(`/runs/${encodeURIComponent(runId)}`, { headers: { ...headers } }));
+  async function leg(fn: (get: Get) => Promise<LegOutcome>): Promise<LegOutcome | { kind: 'skip'; skip: 'blocked' | 'inapplicable'; reason: string }> {
+    const run = await settledRun();
+    if ('skip' in run) return { kind: 'skip', ...run };
+    return fn(runGet(run.runId));
+  }
+
+  it('If-None-Match is evaluated as RFC 9110 defines it: a weak tag, a list holding the tag and `*` match; other tags do not', async () => {
+    const out = await leg(matchLeg);
+    if (out.kind === 'skip') return softSkip(out.skip, out.reason);
+    if (out.kind === 'unreadable') return softSkip('blocked', `run snapshot: ${out.reason}`);
+    expect(out.findings.join('; '), req(ID_MATCH, MATCH_DOC, 'If-None-Match is `*` or a list of entity tags compared weakly (RFC 9110 §13.1.2)')).toBe('');
+  });
+
+  it('a 304 carries the ETag and the Vary of the 200', async () => {
+    const out = await leg(headersLeg);
+    if (out.kind === 'skip') return softSkip(out.skip, out.reason);
+    if (out.kind === 'unreadable') return softSkip('blocked', `run snapshot: ${out.reason}`);
+    expect(out.findings.join('; '), req(ID_304_ETAG, MATCH_DOC, 'on a match the host MUST answer 304 carrying the ETag and the Vary the 200 would carry')).toBe('');
+  });
+
+  it('a request Cache-Control: no-cache does not suppress the evaluation', async () => {
+    const out = await leg(noCacheLeg);
+    if (out.kind === 'skip') return softSkip(out.skip, out.reason);
+    if (out.kind === 'unreadable') return softSkip('blocked', `run snapshot: ${out.reason}`);
+    expect(out.findings.join('; '), req(ID_NO_CACHE, MATCH_DOC, 'a request Cache-Control: no-cache MUST NOT suppress the evaluation')).toBe('');
+  });
+
+  it('a conditional request on a run that does not exist gets the unconditional status, never 304', async () => {
+    const run = await settledRun();
+    if ('skip' in run) return softSkip(run.skip, run.reason);
+    // Same grammar and tenant as a real id, last character changed: an id this host never minted.
+    const last = run.runId.slice(-1);
+    const absent = run.runId.slice(0, -1) + (last === 'a' ? 'b' : 'a');
+    const get = runGet(absent);
+    const plain = await get({});
+    if (plain === null) return softSkip('blocked', 'GET /runs/{runId} on an absent id could not be made');
+    if (plain.status >= 200 && plain.status < 300) return softSkip('blocked', `an id differing from a real run in its last character answered ${plain.status}; no absent run to probe`);
+    const findings: string[] = [];
+    for (const sent of ['*', run.tag]) {
+      const c = await get({ 'If-None-Match': sent });
+      if (c === null) return softSkip('blocked', 'the conditional GET on an absent id could not be made');
+      findings.push(...judgeNot2xx(plain.status, c.status, sent));
+    }
+    expect(findings.join('; '), req(ID_ONLY_2XX, MATCH_DOC, 'If-None-Match is evaluated only when the unconditional response would be 2xx; a run the caller cannot read stays 404')).toBe('');
+  });
 });

package/src/scenarios/v2-self-hosted-runner-advertisement.test.ts

@@ -8,7 +8,7 @@
  *   dispatchKinds  `dispatchKinds` lists `model`, `tool` or both, each once.
  *
  * Not here: registration, subject isolation, at-most-once and liveness need a
- * runner seam; the frame shapes are `v2-self-hosted-runner-frames-static`.
+ * runner seam; the frame shapes are the corpus gate `coherence/v2-self-hosted-runner-frames-static`.
  *
  * Dispositions: discovery unreadable ⇒ `blocked`; `selfHostedRunner` absent, or the
  * facet a leg reads absent ⇒ `inapplicable`.

package/src/scenarios/v2-ai-envelope-shape-static.test.ts

@@ -1,93 +0,0 @@
-/**
- * v2 — the AI envelope wire shape, statically (`spec/v2/core/events.md`
- * §"AI envelopes: E1–E5"; `schemas/v2/ai-envelope.schema.json`). The v1 twin is
- * the static half of `ai-envelope-shape`; its live halves (the
- * `envelope/accept` seam legs) are seam-only and not ported.
- *
- *   compile     `ai-envelope.schema.json` and each universal-kind payload
- *               schema compile under Ajv 2020 with the v2 tree registered;
- *   positive    a well-formed envelope validates — with `correlationId` and
- *               `meta.source`, which v2 makes REQUIRED (migration C4.16);
- *   meta        an envelope without `meta` is rejected;
- *   closed      an unknown top-level property is rejected;
- *   correlation NEW at v2: an envelope without `correlationId` is rejected
- *               ("`correlationId` and `meta.source` are REQUIRED on every
- *               envelope … nothing is synthesized");
- *   source      NEW at v2: an envelope whose `meta` has no `source` is rejected.
- *
- * The `<org>.` namespacing rule for kinds is not witnessed here: the schema's
- * `type` is an open string, so the rule binds the engine's acceptance, not the
- * wire shape.
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see spec/v2/core/events.md §"AI envelopes: E1–E5"
- * @see spec/v1/migrations.json openwop.migration.C4.16
- */
-
-import { describe, it, expect } from 'vitest';
-import { v2Validator } from '../lib/v2.js';
-import { req } from '../lib/requirement-ids.js';
-import { UNIVERSAL_KINDS } from '../lib/envelope-schema-static.js';
-
-const DOC = 'events.md §AI envelopes: E1–E5';
-const ID_COMPILE = 'openwop.requirement.ai-envelope.schemas-compile';
-const ID_POSITIVE = 'openwop.requirement.ai-envelope.well-formed-accepted';
-const ID_META = 'openwop.requirement.ai-envelope.meta-required';
-const ID_CLOSED = 'openwop.requirement.ai-envelope.top-level-closed';
-const ID_CORRELATION = 'openwop.requirement.ai-envelope.correlation-id-required';
-const ID_SOURCE = 'openwop.requirement.ai-envelope.meta-source-required';
-
-const WELL_FORMED = {
-  type: 'clarification.request',
-  schemaVersion: 1,
-  envelopeId: 'env-v2-positive-1',
-  correlationId: 'run-1:node-2:turn-0:abc123',
-  payload: { questions: [{ id: 'q1', question: 'Which provider?' }] },
-  meta: { source: 'ai-generation', ts: '2026-10-04T10:00:00Z', contentTrust: 'trusted' },
-} as const;
-
-/** The well-formed envelope with one top-level field removed. */
-function without(field: string): Record<string, unknown> {
-  const e: Record<string, unknown> = { ...WELL_FORMED };
-  delete e[field];
-  return e;
-}
-
-describe('v2 AI envelope shape: schemas compile', () => {
-  it('ai-envelope.schema.json compiles under Ajv 2020', () => {
-    expect(() => v2Validator('ai-envelope'), req(ID_COMPILE, DOC, 'schemas/v2/ai-envelope.schema.json MUST compile')).not.toThrow();
-  });
-
-  for (const kind of UNIVERSAL_KINDS) {
-    it(`envelopes/${kind}.schema.json compiles under Ajv 2020`, () => {
-      expect(() => v2Validator(`envelopes/${kind}`), req(ID_COMPILE, DOC, `schemas/v2/envelopes/${kind}.schema.json MUST compile`)).not.toThrow();
-    });
-  }
-});
-
-describe('v2 AI envelope shape: round-trip', () => {
-  const validate = v2Validator('ai-envelope');
-
-  it('accepts a well-formed envelope carrying correlationId and meta.source', () => {
-    const r = validate(WELL_FORMED);
-    expect(r.ok, req(ID_POSITIVE, DOC, `a well-formed envelope MUST validate (${r.errors})`)).toBe(true);
-  });
-
-  it('rejects an envelope missing meta', () => {
-    expect(validate(without('meta')).ok, req(ID_META, DOC, 'an envelope without meta MUST be rejected')).toBe(false);
-  });
-
-  it('rejects an envelope with an unknown top-level property', () => {
-    expect(validate({ ...WELL_FORMED, unknownTopLevel: 'x' }).ok, req(ID_CLOSED, 'schemas/v2/ai-envelope.schema.json', 'the envelope is closed: an unknown top-level property MUST be rejected')).toBe(false);
-  });
-
-  it('rejects an envelope missing correlationId', () => {
-    expect(validate(without('correlationId')).ok, req(ID_CORRELATION, DOC, 'correlationId is REQUIRED on every envelope at v2 — an envelope without it MUST be rejected, never synthesized')).toBe(false);
-  });
-
-  it('rejects an envelope whose meta carries no source', () => {
-    const { source: _source, ...meta } = WELL_FORMED.meta;
-    expect(validate({ ...WELL_FORMED, meta }).ok, req(ID_SOURCE, DOC, 'meta.source is REQUIRED on every envelope at v2 — an envelope without it MUST be rejected')).toBe(false);
-  });
-});

package/src/scenarios/v2-artifact-created-static.test.ts

@@ -1,92 +0,0 @@
-/**
- * v2 — the `artifact.created` payload, statically
- * (`spec/v2/core/artifact-type-packs.md` §Registration;
- * `schemas/v2/run-event-payloads.schema.json#/$defs/artifactCreated`; RFCs
- * 0071, 0075, 0138, 0145, 0185). The v1 twins are the schema halves of
- * `artifact-type-store-emission` and `artifact-type-registration-source`;
- * their fixture-run legs are not ported here.
- *
- *   type        `artifact.created` is a registered v2 event type;
- *   required    `artifactId` and `artifactType` are REQUIRED (the RFC 0138
- *               replay correction reads the type from the event);
- *   provenance  `registrationSource` is `pack` or `host` ("pack-registered …
- *               `registrationSource: "pack"`, host-registered … `"host"`"),
- *               and the discovery per-type seat carries the same vocabulary,
- *               so the two surfaces cannot disagree on a value;
- *   registered  `registered` is a boolean;
- *   closed      an unknown key is rejected; a vendor key under the RFC 0185
- *               hatch (`x-`, `vendor.`, `openwop-`) is carried.
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see spec/v2/core/artifact-type-packs.md §Registration
- */
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { SCHEMAS_DIR } from '../lib/paths.js';
-import { v2RefValidator } from '../lib/v2.js';
-import { req } from '../lib/requirement-ids.js';
-
-const DOC = 'artifact-type-packs.md §Registration';
-const ID_TYPE = 'openwop.requirement.artifact-types.created-event-type-registered';
-const ID_REQUIRED = 'openwop.requirement.artifact-types.created-requires-artifact-type';
-const ID_PROVENANCE = 'openwop.requirement.artifact-types.created-registration-source-enum';
-const ID_REGISTERED = 'openwop.requirement.artifact-types.created-registered-boolean';
-const ID_CLOSED = 'openwop.requirement.artifact-types.created-payload-closed';
-
-const GOOD = { artifactId: 'art_1', artifactType: 'vendor.acme.prd', nodeId: 'n1', registered: true, registrationSource: 'host' } as const;
-
-const isRecord = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object' && !Array.isArray(v);
-function enumAt(root: unknown, path: readonly string[]): unknown {
-  let cur: unknown = root;
-  for (const k of path) cur = isRecord(cur) ? cur[k] : undefined;
-  return isRecord(cur) ? cur['enum'] : undefined;
-}
-
-describe('v2 artifact.created payload (artifact-type-packs.md §Registration)', () => {
-  const validate = v2RefValidator('run-event-payloads.schema.json#/$defs/artifactCreated');
-
-  it('artifact.created is a registered v2 run-event type', () => {
-    const r = v2RefValidator('run-event.schema.json#/properties/type')('artifact.created');
-    expect(r.ok, req(ID_TYPE, DOC, `artifact.created MUST be accepted by the v2 run-event type union (${r.errors})`)).toBe(true);
-  });
-
-  it('accepts a well-formed payload, with either provenance or none', () => {
-    const { registrationSource: _src, ...noSource } = GOOD;
-    for (const p of [GOOD, { ...GOOD, registrationSource: 'pack' }, noSource]) {
-      const r = validate(p);
-      expect(r.ok, req(ID_PROVENANCE, DOC, `artifact.created ${JSON.stringify(p)} MUST validate (${r.errors})`)).toBe(true);
-    }
-  });
-
-  it.each(['artifactId', 'artifactType'])('rejects a payload without %s', (field) => {
-    const p: Record<string, unknown> = { ...GOOD };
-    delete p[field];
-    expect(validate(p).ok, req(ID_REQUIRED, DOC, `artifact.created without ${field} MUST be rejected`)).toBe(false);
-  });
-
-  it('rejects a registrationSource outside pack | host', () => {
-    expect(validate({ ...GOOD, registrationSource: 'vendor' }).ok, req(ID_PROVENANCE, DOC, 'registrationSource MUST be pack or host')).toBe(false);
-  });
-
-  it('the discovery per-type registrationSource carries the same vocabulary as the event', () => {
-    const payloads: unknown = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'v2', 'run-event-payloads.schema.json'), 'utf8'));
-    const caps: unknown = JSON.parse(readFileSync(join(SCHEMAS_DIR, 'v2', 'capabilities.schema.json'), 'utf8'));
-    const event = enumAt(payloads, ['$defs', 'artifactCreated', 'properties', 'registrationSource']);
-    const advert = enumAt(caps, ['properties', 'artifactTypes', 'properties', 'types', 'additionalProperties', 'properties', 'registrationSource']);
-    expect(event, req(ID_PROVENANCE, DOC, 'artifact.created.registrationSource MUST be the pack | host enum')).toEqual(['pack', 'host']);
-    expect(advert, req(ID_PROVENANCE, 'capabilities.schema.json §artifactTypes.types', 'the advertised per-type registrationSource MUST use the vocabulary artifact.created carries')).toEqual(event);
-  });
-
-  it('rejects a non-boolean registered', () => {
-    expect(validate({ ...GOOD, registered: 'true' }).ok, req(ID_REGISTERED, DOC, 'registered MUST be a boolean')).toBe(false);
-  });
-
-  it('rejects an unknown key, and carries a vendor key under the RFC 0185 hatch', () => {
-    expect(validate({ ...GOOD, payload: { secret: 1 } }).ok, req(ID_CLOSED, DOC, 'an unknown key on artifact.created MUST be rejected')).toBe(false);
-    const r = validate({ ...GOOD, 'x-acme-trace': 'abc', 'vendor.acme.note': 'n' });
-    expect(r.ok, req(ID_CLOSED, 'run-event-payloads.schema.json §artifactCreated (RFC 0185)', `a vendor-prefixed key MUST be carried (${r.errors})`)).toBe(true);
-  });
-});

package/src/scenarios/v2-envelope-variant-discriminator-static.test.ts

@@ -1,57 +0,0 @@
-/**
- * v2 — variant payload discrimination, statically (RFC 0031 §A). The v1 twin
- * is `envelope-variant-discriminator-static`; the walker lives in
- * `lib/envelope-schema-static.ts`.
- *
- * For every payload schema in `schemas/v2/envelopes/`:
- *   no oneOf       `oneOf` appears at no depth (Gemini drops it silently, so a
- *                  model gets a looser schema than declared);
- *   discriminated  in a variant union — an `anyOf` where two or more branches
- *                  can be objects — every object branch declares, in `required`,
- *                  a property of `type: string` with a one-value `enum`; a `$ref`
- *                  branch is accepted unresolved, as at v1. A type union with at
- *                  most one object branch (`string | binding`, as
- *                  `ui.a2ui-surface` payload v2's `dyn*` defs declare) is
- *                  selected by JSON type and is not judged: a scalar branch has
- *                  no property to discriminate on. This scoping is new at v2 —
- *                  the v1 walker flagged every non-`$ref` branch, which no v1
- *                  schema exercised.
- *
- * No v2 core document states this rule: `spec/v2/core/` carries no text on
- * variant payload discrimination (the nearest is `ext/a2uiSurface/README.md`,
- * whose components are "discriminated by a single-string-enum `component`").
- * The requirement is cited to RFC 0031 §A, its only normative home.
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see RFCS/0031-envelope-variants-and-model-capabilities.md §A
- */
-
-import { describe, it, expect } from 'vitest';
-import { req } from '../lib/requirement-ids.js';
-import { anyOfDiscriminatorViolations, listV2EnvelopeKinds, loadV2EnvelopeSchema, oneOfViolations, UNIVERSAL_KINDS } from '../lib/envelope-schema-static.js';
-
-const DOC = 'RFC 0031 §A';
-const ID_PRESENT = 'openwop.requirement.envelopes.payload-schemas-present';
-const ID_NO_ONEOF = 'openwop.requirement.envelopes.variant-no-oneof';
-const ID_DISCRIMINATED = 'openwop.requirement.envelopes.variant-anyof-discriminated';
-
-const KINDS = listV2EnvelopeKinds();
-
-describe('v2 envelope variant discrimination (RFC 0031 §A)', () => {
-  it('schemas/v2/envelopes carries a payload schema for each universal kind', () => {
-    for (const k of UNIVERSAL_KINDS) expect(KINDS.includes(k), req(ID_PRESENT, DOC, `schemas/v2/envelopes/${k}.schema.json MUST exist`)).toBe(true);
-  });
-
-  for (const kind of KINDS) {
-    it(`${kind} contains no oneOf at any depth`, () => {
-      const v = oneOfViolations(loadV2EnvelopeSchema(kind));
-      expect(v, req(ID_NO_ONEOF, DOC, `${kind} MUST NOT use oneOf — use anyOf with a single-string-enum discriminator: ${JSON.stringify(v)}`)).toEqual([]);
-    });
-
-    it(`${kind} discriminates every anyOf branch by a single-string-enum property`, () => {
-      const v = anyOfDiscriminatorViolations(loadV2EnvelopeSchema(kind));
-      expect(v, req(ID_DISCRIMINATED, DOC, `${kind} anyOf branches without a discriminator: ${JSON.stringify(v)}`)).toEqual([]);
-    });
-  }
-});

package/src/scenarios/v2-export-bundle-static.test.ts

@@ -1,108 +0,0 @@
-/**
- * v2 — the export bundle, the `import.applied` payload and the `portability`
- * record's `import ⇒ dryRun` rule, statically (`spec/v2/core/portability.md`;
- * RFC 0098; invariant `export-bundle-no-credential-material`). The v1 twin is
- * the server-free half of `export-bundle-portability`; its import-seam leg is
- * not ported (v2 defines no import route).
- *
- *   version     a bundle carries `bundleVersion: "2"`. This FLIPS the v1 leg:
- *               at v1 `"1"` was good and `"2"` rejected; at v2 `"1"` is
- *               rejected;
- *   shape       an unknown item kind and an item without `ref` are rejected;
- *   no-cred     no credential-named field is admitted at the bundle root or
- *               under `source` ("A bundle MUST NOT contain credential values");
- *   applied     `import.applied` is a registered v2 event type, and its payload
- *               is counts and references only, never item payloads;
- *   dryRun      the capabilities seat refuses `import: true` without
- *               `dryRun: true` ("A host advertising `import` MUST advertise
- *               `dryRun: true`"). At v2 that `if/then` sits in the record's
- *               `allOf`, so it is witnessed by validation, not by reading
- *               `portability.if`.
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see spec/v2/core/portability.md
- * @see schemas/v2/export-bundle.schema.json
- */
-
-import { describe, it, expect } from 'vitest';
-import { v2RefValidator, v2Validator } from '../lib/v2.js';
-import { req } from '../lib/requirement-ids.js';
-
-const DOC = 'portability.md §The export bundle';
-const ID_VERSION = 'openwop.requirement.portability.bundle-version-2';
-const ID_SHAPE = 'openwop.requirement.portability.bundle-item-shape';
-const ID_NO_CRED = 'openwop.requirement.portability.bundle-no-credential-field';
-const ID_APPLIED = 'openwop.requirement.portability.import-applied-content-free';
-const ID_DRY_RUN = 'openwop.requirement.portability.import-dry-run-schema-rule';
-
-const CRED_NAMES = ['clientSecret', 'client_secret', 'apiKey', 'api_key', 'accessToken', 'refreshToken', 'password', 'privateKey'] as const;
-
-const GOOD = {
-  bundleVersion: '2',
-  source: { origin: 'https://host-a.example', exportedAt: '2026-10-04T00:00:00Z' },
-  items: [
-    { kind: 'prompt-template', ref: 'tpl-1', payload: { templateId: 'welcome', version: '1.0.0' } },
-    { kind: 'connection-ref', ref: 'conn-1', dependsOn: ['tpl-1'], payload: { provider: 'slack', credentialRef: 'cred:abc' } },
-  ],
-} as const;
-
-describe('v2 export bundle (portability.md §The export bundle)', () => {
-  const validate = v2Validator('export-bundle');
-
-  it('accepts a conforming bundle at bundleVersion "2"', () => {
-    const r = validate(GOOD);
-    expect(r.ok, req(ID_VERSION, DOC, `a conforming v2 bundle MUST validate (${r.errors})`)).toBe(true);
-  });
-
-  it('rejects the v1 bundleVersion "1" and a missing bundleVersion', () => {
-    expect(validate({ ...GOOD, bundleVersion: '1' }).ok, req(ID_VERSION, DOC, 'a v2 bundle MUST carry bundleVersion "2"; "1" MUST be rejected')).toBe(false);
-    const { bundleVersion: _gone, ...rest } = GOOD;
-    expect(validate(rest).ok, req(ID_VERSION, DOC, 'a bundle without bundleVersion MUST be rejected')).toBe(false);
-  });
-
-  it('rejects an unknown item kind and an item without ref', () => {
-    expect(validate({ ...GOOD, items: [{ kind: 'workflow', ref: 'x', payload: {} }] }).ok, req(ID_SHAPE, DOC, 'an unknown item kind MUST be rejected')).toBe(false);
-    expect(validate({ ...GOOD, items: [{ kind: 'agent', payload: {} }] }).ok, req(ID_SHAPE, DOC, 'an item without a ref MUST be rejected')).toBe(false);
-  });
-
-  it.each(CRED_NAMES)('admits no %s field at the bundle root or under source', (name) => {
-    expect(validate({ ...GOOD, [name]: 'xxx' }).ok, req(ID_NO_CRED, DOC, `a "${name}" field at the bundle root MUST NOT validate`)).toBe(false);
-    expect(validate({ ...GOOD, source: { ...GOOD.source, [name]: 'xxx' } }).ok, req(ID_NO_CRED, DOC, `a "${name}" field under source MUST NOT validate`)).toBe(false);
-  });
-});
-
-describe('v2 import.applied (portability.md §The import.applied event)', () => {
-  const applied = v2RefValidator('run-event-payloads.schema.json#/$defs/importApplied');
-  const ADOC = 'portability.md §The import.applied event';
-
-  it('import.applied is a registered v2 run-event type', () => {
-    const r = v2RefValidator('run-event.schema.json#/properties/type')('import.applied');
-    expect(r.ok, req(ID_APPLIED, ADOC, `import.applied MUST be accepted by the v2 run-event type union (${r.errors})`)).toBe(true);
-  });
-
-  it('a counts-and-refs payload validates; one carrying item payloads does not', () => {
-    const r = applied({ bundleOrigin: 'https://host-a.example', counts: { created: 2, skipped: 1 }, secretsToRebind: ['anthropic'] });
-    expect(r.ok, req(ID_APPLIED, ADOC, `a content-free import.applied MUST validate (${r.errors})`)).toBe(true);
-    expect(applied({ bundleOrigin: 'h', counts: { created: 1 }, items: [{ payload: {} }] }).ok, req(ID_APPLIED, ADOC, 'import.applied MUST NOT carry item payloads')).toBe(false);
-    expect(applied({ bundleOrigin: 'h', counts: { created: 1, leaked: 1 } }).ok, req(ID_APPLIED, ADOC, 'import.applied counts MUST be the four outcome tallies only')).toBe(false);
-  });
-});
-
-describe('v2 portability record: import ⇒ dryRun (portability.md §The portability record)', () => {
-  const record = v2RefValidator('capabilities.schema.json#/properties/portability');
-  const PDOC = 'portability.md §The portability record';
-  const base = { status: 'experimental', since: '2.0', until: '2099-01-01', witness: 'witnessable-gated', export: true } as const;
-
-  it('import: true with dryRun: true validates; import: false needs no dryRun', () => {
-    for (const r of [{ ...base, import: true, dryRun: true }, { ...base, import: false }, { ...base }]) {
-      const v = record(r);
-      expect(v.ok, req(ID_DRY_RUN, PDOC, `a portability record ${JSON.stringify(r)} MUST validate (${v.errors})`)).toBe(true);
-    }
-  });
-
-  it('import: true without dryRun, or with dryRun: false, is rejected', () => {
-    expect(record({ ...base, import: true }).ok, req(ID_DRY_RUN, PDOC, 'import: true without dryRun MUST be rejected')).toBe(false);
-    expect(record({ ...base, import: true, dryRun: false }).ok, req(ID_DRY_RUN, PDOC, 'import: true with dryRun: false MUST be rejected')).toBe(false);
-  });
-});

package/src/scenarios/v2-media-inline-cap-static.test.ts

@@ -1,59 +0,0 @@
-/**
- * v2 — the `media.*` payload shapes, statically (`spec/v2/core/host-services.md`
- * §aiProviders: "A `media.*` envelope inlines base64 only up to
- * `maxInlineMediaBytes` (default 256 KiB); above that the host MUST use a
- * `url`"; RFC 0055 §C). The v1 twin is the static half of
- * `media-url-inline-cap`. Its advertisement leg (`aiProviders.maxInlineMediaBytes`)
- * is in `v2-ai-providers-advertisement`; its seam legs (the media store and the
- * debug-bundle walk) are not ported.
- *
- *   compile   the three `media.{image,audio,file}` schemas compile;
- *   url       a URL-reference payload validates;
- *   inline    an inline-base64 payload validates;
- *   bytes     a payload without `bytes` is rejected (`bytes` is what a cap is
- *             judged against);
- *   closed    an unknown property is rejected.
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see spec/v2/core/host-services.md §aiProviders
- * @see schemas/v2/envelopes/media.image.schema.json
- */
-
-import { describe, it, expect } from 'vitest';
-import { v2Validator } from '../lib/v2.js';
-import { req } from '../lib/requirement-ids.js';
-
-const DOC = 'host-services.md §aiProviders';
-const MEDIA_KINDS = ['media.image', 'media.audio', 'media.file'] as const;
-const ID_COMPILE = 'openwop.requirement.media.payload-schemas-compile';
-const ID_URL = 'openwop.requirement.media.url-reference-accepted';
-const ID_INLINE = 'openwop.requirement.media.inline-base64-accepted';
-const ID_BYTES = 'openwop.requirement.media.bytes-required';
-const ID_CLOSED = 'openwop.requirement.media.payload-closed';
-
-describe('v2 media payload shapes (host-services.md §aiProviders)', () => {
-  for (const kind of MEDIA_KINDS) {
-    it(`envelopes/${kind}.schema.json compiles under Ajv 2020`, () => {
-      expect(() => v2Validator(`envelopes/${kind}`), req(ID_COMPILE, DOC, `schemas/v2/envelopes/${kind}.schema.json MUST compile`)).not.toThrow();
-    });
-  }
-
-  it('accepts a URL-reference image payload', () => {
-    const r = v2Validator('envelopes/media.image')({ url: 'https://host.example/runs/run_1/assets/img_9.png', bytes: 184320, mimeType: 'image/png' });
-    expect(r.ok, req(ID_URL, DOC, `a URL-reference media payload MUST validate (${r.errors})`)).toBe(true);
-  });
-
-  it('accepts an inline-base64 audio payload', () => {
-    const r = v2Validator('envelopes/media.audio')({ base64: 'AAAA', bytes: 3, mimeType: 'audio/ogg', durationSeconds: 1.2 });
-    expect(r.ok, req(ID_INLINE, DOC, `an inline-base64 media payload MUST validate (${r.errors})`)).toBe(true);
-  });
-
-  it('rejects a media payload missing bytes', () => {
-    expect(v2Validator('envelopes/media.file')({ url: 'https://host.example/runs/run_1/assets/report.pdf' }).ok, req(ID_BYTES, DOC, 'bytes is required on a media payload — it is what the inline cap is judged against')).toBe(false);
-  });
-
-  it('rejects a media payload with an unknown property', () => {
-    expect(v2Validator('envelopes/media.image')({ bytes: 1, wat: true }).ok, req(ID_CLOSED, DOC, 'a media payload is closed: an unknown property MUST be rejected')).toBe(false);
-  });
-});

package/src/scenarios/v2-provider-usage-payload-static.test.ts

@@ -1,92 +0,0 @@
-/**
- * v2 — the `provider.usage` payload, statically (`spec/v2/core/events.md`
- * §providerUsage; `schemas/v2/run-event-payloads.schema.json#/$defs/providerUsage`;
- * RFC 0026; invariant `provider-usage-no-credential-leak`). The v1 twin is the
- * schema half of `provider-usage`; its emit-seam legs (and the v1
- * `provider_usage_credential_leak` code, which `spec/v2/errors.json` does not
- * carry) are not ported.
- *
- *   type       `provider.usage` is a registered v2 event type;
- *   positive   a payload with the four required fields, and one with every
- *              optional field, validates;
- *   required   a payload missing provider, model, inputTokens or outputTokens
- *              is rejected;
- *   counts     a fractional or negative token count is rejected;
- *   cost       a negative `costEstimateUsd` is rejected; `currency` is an
- *              ISO 4217 code ("`providerUsage.currency` is the ISO 4217
- *              currency of `costEstimateUsd`");
- *   no-leak    the payload is closed, so a credential ref, a hashed credential
- *              id or prompt/response text is rejected ("The payload MUST NOT
- *              carry credential refs, hashed credential identifiers, or prompt
- *              or response text").
- *
- * Host-free: every leg runs with no OPENWOP_BASE_URL.
- *
- * @see spec/v2/core/events.md §providerUsage
- */
-
-import { describe, it, expect } from 'vitest';
-import { v2RefValidator } from '../lib/v2.js';
-import { req } from '../lib/requirement-ids.js';
-
-const DOC = 'events.md §providerUsage';
-const ID_TYPE = 'openwop.requirement.provider-usage.event-type-registered';
-const ID_POSITIVE = 'openwop.requirement.provider-usage.payload-well-formed-accepted';
-const ID_REQUIRED = 'openwop.requirement.provider-usage.payload-required-fields';
-const ID_COUNTS = 'openwop.requirement.provider-usage.payload-token-counts';
-const ID_COST = 'openwop.requirement.provider-usage.payload-cost-and-currency';
-const ID_NO_LEAK = 'openwop.requirement.provider-usage.payload-no-credential-or-content';
-
-const MINIMAL = { provider: 'anthropic', model: 'claude-x', inputTokens: 120, outputTokens: 30 } as const;
-const FULL = { ...MINIMAL, totalTokens: 150, costEstimateUsd: 0.0021, currency: 'EUR', cacheHit: false, cacheReadTokens: 0, cacheWriteTokens: 64 } as const;
-
-function without(field: string): Record<string, unknown> {
-  const c: Record<string, unknown> = { ...MINIMAL };
-  delete c[field];
-  return c;
-}
-
-describe('v2 provider.usage payload (events.md §providerUsage)', () => {
-  const validate = v2RefValidator('run-event-payloads.schema.json#/$defs/providerUsage');
-
-  it('provider.usage is a registered v2 run-event type', () => {
-    const r = v2RefValidator('run-event.schema.json#/properties/type')('provider.usage');
-    expect(r.ok, req(ID_TYPE, DOC, `provider.usage MUST be accepted by the v2 run-event type union (${r.errors})`)).toBe(true);
-  });
-
-  it('accepts a minimal and a full payload', () => {
-    for (const p of [MINIMAL, FULL]) {
-      const r = validate(p);
-      expect(r.ok, req(ID_POSITIVE, DOC, `a well-formed provider.usage payload MUST validate (${r.errors})`)).toBe(true);
-    }
-  });
-
-  it.each(['provider', 'model', 'inputTokens', 'outputTokens'])('rejects a payload without %s', (field) => {
-    expect(validate(without(field)).ok, req(ID_REQUIRED, DOC, `a provider.usage payload without ${field} MUST be rejected`)).toBe(false);
-  });
-
-  it.each<[string, Record<string, unknown>]>([
-    ['a fractional inputTokens', { ...MINIMAL, inputTokens: 1.5 }],
-    ['a negative outputTokens', { ...MINIMAL, outputTokens: -1 }],
-    ['a string inputTokens', { ...MINIMAL, inputTokens: '120' }],
-  ])('rejects %s', (what, p) => {
-    expect(validate(p).ok, req(ID_COUNTS, DOC, `a provider.usage payload with ${what} MUST be rejected`)).toBe(false);
-  });
-
-  it.each<[string, Record<string, unknown>]>([
-    ['a negative costEstimateUsd', { ...MINIMAL, costEstimateUsd: -0.01 }],
-    ['a lower-case currency', { ...MINIMAL, costEstimateUsd: 0.01, currency: 'usd' }],
-    ['a currency symbol', { ...MINIMAL, costEstimateUsd: 0.01, currency: '$' }],
-  ])('rejects %s', (what, p) => {
-    expect(validate(p).ok, req(ID_COST, DOC, `a provider.usage payload with ${what} MUST be rejected`)).toBe(false);
-  });
-
-  it.each<[string, Record<string, unknown>]>([
-    ['a credential ref', { ...MINIMAL, credentialRef: 'secret:tenant:byok-anthropic:v1' }],
-    ['a hashed credential id', { ...MINIMAL, credentialHash: 'sha256:9f2c' }],
-    ['prompt text', { ...MINIMAL, prompt: 'summarize the attached notes' }],
-    ['response text', { ...MINIMAL, response: 'Here is a summary' }],
-  ])('rejects a payload carrying %s', (what, p) => {
-    expect(validate(p).ok, req(ID_NO_LEAK, DOC, `the provider.usage payload MUST NOT carry ${what}`)).toBe(false);
-  });
-});