@hypequery/protocol-conformance 0.0.0-canary-20260722115402

package/dist/manifest.js

@@ -0,0 +1,118 @@
+function decodePointerToken(token) {
+    return token.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+/** Minimal RFC 6901 JSON pointer resolution for the section selectors. */
+export function resolveJsonPointer(root, pointer) {
+    if (pointer === '')
+        return root;
+    if (!pointer.startsWith('/')) {
+        throw new Error(`Invalid JSON pointer: ${pointer}`);
+    }
+    let current = root;
+    for (const rawToken of pointer.slice(1).split('/')) {
+        const token = decodePointerToken(rawToken);
+        if (Array.isArray(current)) {
+            current = current[Number(token)];
+        }
+        else if (current !== null && typeof current === 'object') {
+            current = current[token];
+        }
+        else {
+            throw new Error(`JSON pointer ${pointer} does not resolve`);
+        }
+    }
+    return current;
+}
+function asCaseArray(value, context) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Expected an array of cases at ${context}`);
+    }
+    return value;
+}
+function requireId(entry, context) {
+    const id = entry.id;
+    if (typeof id !== 'string' || id.length === 0) {
+        throw new Error(`Fixture case at ${context} is missing a string id`);
+    }
+    return id;
+}
+function enumerateFile(family, file, loadJson) {
+    const data = loadJson(file.path);
+    const cases = [];
+    const pushArray = (array, section) => {
+        for (const entry of array) {
+            cases.push({
+                family: family.name,
+                role: file.role,
+                id: requireId(entry, `${file.path}${section ?? ''}`),
+                section,
+                case: entry,
+            });
+        }
+    };
+    if (file.sections && file.sections.length > 0) {
+        for (const section of file.sections) {
+            pushArray(asCaseArray(resolveJsonPointer(data, section), `${file.path}${section}`), section);
+        }
+    }
+    else {
+        pushArray(asCaseArray(data, file.path));
+    }
+    return cases;
+}
+/** Cases derived from the family fixture files, in manifest order. */
+export function enumerateFamilyCases(manifest, loadJson) {
+    return manifest.families.flatMap((family) => {
+        const cases = family.files.flatMap((file) => enumerateFile(family, file, loadJson));
+        // An identity case pins the canonical bytes and hash of the success case
+        // that shares its id. Attach that success value so an adapter can derive
+        // the canonical form without loading the success file itself.
+        const successValues = new Map();
+        for (const ec of cases) {
+            if (ec.role === 'success')
+                successValues.set(ec.id, ec.case.value);
+        }
+        return cases.map((ec) => {
+            if (ec.role !== 'identity')
+                return ec;
+            if (!successValues.has(ec.id)) {
+                throw new Error(`Identity case ${family.name}/${ec.id} has no matching success value`);
+            }
+            return { ...ec, case: { ...ec.case, value: successValues.get(ec.id) } };
+        });
+    });
+}
+/**
+ * Cases derived from the fuzz corpus. A seed with its own `targets` fans out
+ * to one case per target family; otherwise it uses the manifest entry family.
+ */
+export function enumerateFuzzCases(manifest, loadJson) {
+    const cases = [];
+    for (const entry of manifest.fuzz) {
+        const seeds = asCaseArray(loadJson(entry.path), entry.path);
+        for (const seed of seeds) {
+            const seedId = requireId(seed, entry.path);
+            const targets = Array.isArray(seed.targets)
+                ? seed.targets
+                : entry.family !== undefined
+                    ? [entry.family]
+                    : [];
+            if (targets.length === 0) {
+                throw new Error(`Fuzz seed ${seedId} in ${entry.path} has no target family`);
+            }
+            const fanOut = targets.length > 1;
+            for (const family of targets) {
+                cases.push({
+                    family,
+                    role: 'fuzz',
+                    id: fanOut ? `${seedId}@${family}` : seedId,
+                    case: seed,
+                });
+            }
+        }
+    }
+    return cases;
+}
+export function enumerateAllCases(manifest, loadJson) {
+    return [...enumerateFamilyCases(manifest, loadJson), ...enumerateFuzzCases(manifest, loadJson)];
+}

package/dist/report.d.ts

@@ -0,0 +1,4 @@
+import type { RunSummary } from './types.js';
+export declare function formatJsonReport(summary: RunSummary): string;
+export declare function formatPrettyReport(summary: RunSummary): string;
+//# sourceMappingURL=report.d.ts.map

package/dist/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../src/report.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAsB9D"}

package/dist/report.js

@@ -0,0 +1,23 @@
+export function formatJsonReport(summary) {
+    return JSON.stringify(summary, null, 2);
+}
+export function formatPrettyReport(summary) {
+    const lines = [];
+    const adapter = summary.adapter;
+    const label = adapter?.implementation
+        ? `${adapter.implementation}${adapter.version ? `@${adapter.version}` : ''}`
+        : 'adapter';
+    lines.push(`Conformance run against ${label}${adapter?.language ? ` (${adapter.language})` : ''}`);
+    for (const outcome of summary.outcomes) {
+        if (outcome.status === 'pass')
+            continue;
+        const mark = outcome.status === 'skip' ? 'SKIP' : 'FAIL';
+        const detail = [outcome.expected ? `expected ${outcome.expected}` : '', outcome.actual ? `got ${outcome.actual}` : '', outcome.message ?? '']
+            .filter(Boolean)
+            .join(', ');
+        lines.push(`  ${mark} ${outcome.family}/${outcome.role}/${outcome.id}${detail ? ` — ${detail}` : ''}`);
+    }
+    lines.push(`${summary.passed} passed, ${summary.failed} failed, ${summary.skipped} skipped`
+        + (summary.notRun > 0 ? `, ${summary.notRun} not run (family not announced)` : ''));
+    return lines.join('\n');
+}

package/dist/runner.d.ts

@@ -0,0 +1,12 @@
+import { type RunSummary } from './types.js';
+export interface RunConformanceOptions {
+    readonly adapterCommand: readonly string[];
+    readonly fixturesDir?: string;
+    /** Restrict to these families (intersected with what the adapter announces). */
+    readonly families?: readonly string[];
+    readonly timeoutMs?: number;
+    readonly skipFuzz?: boolean;
+    readonly onlyFuzz?: boolean;
+}
+export declare function runConformance(options: RunConformanceOptions): Promise<RunSummary>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAQA,OAAO,EAML,KAAK,UAAU,EAChB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC7B;AA6FD,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,UAAU,CAAC,CA4FxF"}

package/dist/runner.js

@@ -0,0 +1,197 @@
+// Drives an adapter over NDJSON: handshake, then one case at a time with a
+// per-case timeout. On a premature adapter exit the runner respawns once and
+// continues; a second premature exit fails the run.
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { compareCase } from './compare.js';
+import { createJsonLoader, loadManifest, resolveFixturesDir } from './fs.js';
+import { enumerateAllCases } from './manifest.js';
+import { CONFORMANCE_MANIFEST_VERSION, CONFORMANCE_PROTOCOL_VERSION, } from './types.js';
+const DEFAULT_TIMEOUT_MS = 5_000;
+class AdapterExitError extends Error {
+}
+class AdapterTimeoutError extends Error {
+}
+/** A single adapter child process with a line-oriented message queue. */
+class AdapterConnection {
+    child;
+    rl;
+    queue = [];
+    waiter;
+    exited = false;
+    constructor(command) {
+        this.child = spawn(command[0], command.slice(1), { shell: false });
+        this.child.stderr.pipe(process.stderr);
+        this.rl = createInterface({ input: this.child.stdout, crlfDelay: Infinity });
+        this.rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (trimmed === '')
+                return;
+            let message;
+            try {
+                message = JSON.parse(trimmed);
+            }
+            catch {
+                return;
+            }
+            if (this.waiter) {
+                const resolve = this.waiter;
+                this.waiter = undefined;
+                resolve(message);
+            }
+            else {
+                this.queue.push(message);
+            }
+        });
+        this.child.on('exit', () => {
+            this.exited = true;
+        });
+    }
+    write(message) {
+        if (!this.exited)
+            this.child.stdin.write(`${JSON.stringify(message)}\n`);
+    }
+    nextMessage(timeoutMs) {
+        const queued = this.queue.shift();
+        if (queued)
+            return Promise.resolve(queued);
+        if (this.exited)
+            return Promise.reject(new AdapterExitError('adapter exited'));
+        return new Promise((resolve, reject) => {
+            // A single settle path clears the timer, the exit listener, and the
+            // waiter so no timer can reject a promise that already resolved.
+            const settle = (fn) => {
+                clearTimeout(timer);
+                this.child.removeListener('exit', onExit);
+                this.waiter = undefined;
+                fn();
+            };
+            const onExit = () => settle(() => reject(new AdapterExitError('adapter exited')));
+            const timer = setTimeout(() => settle(() => reject(new AdapterTimeoutError('timed out waiting for result'))), timeoutMs);
+            this.child.once('exit', onExit);
+            this.waiter = (message) => settle(() => resolve(message));
+        });
+    }
+    async handshake(timeoutMs) {
+        this.write({
+            type: 'hello',
+            protocol: CONFORMANCE_PROTOCOL_VERSION,
+            manifestVersion: CONFORMANCE_MANIFEST_VERSION,
+        });
+        const message = await this.nextMessage(timeoutMs);
+        if (message.type !== 'hello' || !Array.isArray(message.families)) {
+            throw new Error('adapter did not answer the handshake');
+        }
+        return message;
+    }
+    end() {
+        this.write({ type: 'end' });
+        this.child.stdin.end();
+    }
+    kill() {
+        if (!this.exited)
+            this.child.kill('SIGKILL');
+    }
+}
+export async function runConformance(options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const fixturesDir = resolveFixturesDir(options.fixturesDir);
+    const manifest = loadManifest(fixturesDir);
+    const loadJson = createJsonLoader(fixturesDir);
+    let cases = enumerateAllCases(manifest, loadJson);
+    if (options.onlyFuzz)
+        cases = cases.filter((c) => c.role === 'fuzz');
+    if (options.skipFuzz)
+        cases = cases.filter((c) => c.role !== 'fuzz');
+    if (options.families && options.families.length > 0) {
+        const requested = new Set(options.families);
+        cases = cases.filter((c) => requested.has(c.family));
+    }
+    // The handshake covers process spawn plus the adapter's first write, which
+    // can be slow under load; it gets a generous timeout independent of the
+    // per-case timeout so a busy machine never mistakes startup for a hang.
+    const handshakeTimeoutMs = Math.max(timeoutMs, DEFAULT_TIMEOUT_MS);
+    let connection = new AdapterConnection(options.adapterCommand);
+    let hello = await connection.handshake(handshakeTimeoutMs);
+    let announced = new Set(hello.families);
+    let respawnBudget = 1;
+    const outcomes = [];
+    let seq = 0;
+    let notRun = 0;
+    for (const ec of cases) {
+        if (!announced.has(ec.family)) {
+            notRun += 1;
+            continue;
+        }
+        seq += 1;
+        connection.write({
+            type: 'case',
+            seq,
+            family: ec.family,
+            role: ec.role,
+            id: ec.id,
+            ...(ec.section ? { section: ec.section } : {}),
+            case: ec.case,
+        });
+        try {
+            const message = await connection.nextMessage(timeoutMs);
+            if (message.type !== 'result' || message.seq !== seq) {
+                outcomes.push(failure(ec, 'protocol error', 'out-of-order result'));
+                continue;
+            }
+            outcomes.push(compareCase(ec, message));
+        }
+        catch (error) {
+            outcomes.push(failure(ec, 'a result', error instanceof AdapterTimeoutError ? 'timeout' : 'adapter exited'));
+            // Both failures leave the connection unusable: a crashed child is gone,
+            // and a timed-out child may still deliver a late reply that would be
+            // consumed as the next case's result — or block every later case and
+            // outlive the run. Kill it and start fresh before continuing. Crashes are
+            // rate-limited because they can recur instantly; timeouts are naturally
+            // bounded by the per-case timeout, so they always refresh.
+            if (error instanceof AdapterExitError) {
+                if (respawnBudget <= 0)
+                    break;
+                respawnBudget -= 1;
+            }
+            if (!(await refreshConnection()))
+                break;
+        }
+    }
+    connection.end();
+    return summarize(outcomes, notRun, hello);
+    async function refreshConnection() {
+        connection.kill();
+        connection = new AdapterConnection(options.adapterCommand);
+        try {
+            hello = await connection.handshake(handshakeTimeoutMs);
+        }
+        catch {
+            // A replacement that cannot even complete a handshake ends the run
+            // cleanly rather than throwing out of the loop.
+            return false;
+        }
+        announced = new Set(hello.families);
+        seq = 0;
+        return true;
+    }
+}
+function failure(ec, expected, actual) {
+    return { family: ec.family, role: ec.role, id: ec.id, status: 'fail', expected, actual };
+}
+function summarize(outcomes, notRun, hello) {
+    return {
+        total: outcomes.length,
+        passed: outcomes.filter((o) => o.status === 'pass').length,
+        failed: outcomes.filter((o) => o.status === 'fail').length,
+        skipped: outcomes.filter((o) => o.status === 'skip').length,
+        notRun,
+        adapter: {
+            implementation: hello.implementation,
+            version: hello.version,
+            language: hello.language,
+            families: hello.families,
+        },
+        outcomes,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,84 @@
+export declare const CONFORMANCE_PROTOCOL_VERSION = 1;
+export declare const CONFORMANCE_MANIFEST_VERSION = 1;
+export type FixtureRole = 'success' | 'rejection' | 'identity' | 'portable' | 'non-portable' | 'fuzz';
+export interface ManifestFileEntry {
+    readonly path: string;
+    readonly role: Exclude<FixtureRole, 'fuzz'>;
+    /** JSON pointers to the case arrays when the file root is not an array. */
+    readonly sections?: readonly string[];
+}
+export interface ManifestFamily {
+    readonly name: string;
+    readonly rfc?: string;
+    readonly codePrefixes: readonly string[];
+    readonly files: readonly ManifestFileEntry[];
+}
+export interface ManifestFuzzEntry {
+    readonly path: string;
+    /** Default target family when a seed does not carry its own `targets`. */
+    readonly family?: string;
+}
+export interface ConformanceManifest {
+    readonly kind: 'hypequery-conformance-manifest';
+    readonly version: number;
+    readonly families: readonly ManifestFamily[];
+    readonly fuzz: readonly ManifestFuzzEntry[];
+}
+/** A single case the runner sends to an adapter. */
+export interface EnumeratedCase {
+    readonly family: string;
+    readonly role: FixtureRole;
+    readonly id: string;
+    /** JSON pointer the case was read from, when the file declared sections. */
+    readonly section?: string;
+    readonly case: Record<string, unknown>;
+}
+export interface AdapterHello {
+    readonly type: 'hello';
+    readonly protocol: number;
+    readonly implementation?: string;
+    readonly version?: string;
+    readonly language?: string;
+    readonly families: readonly string[];
+}
+export type HandlerResult = {
+    readonly ok: true;
+    readonly output?: Record<string, unknown>;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly output?: Record<string, unknown>;
+} | {
+    readonly skipped: true;
+    readonly reason?: string;
+};
+export type CaseResult = HandlerResult & {
+    readonly type: 'result';
+    readonly seq: number;
+};
+export type CaseStatus = 'pass' | 'fail' | 'skip';
+export interface CaseOutcome {
+    readonly family: string;
+    readonly role: FixtureRole;
+    readonly id: string;
+    readonly status: CaseStatus;
+    readonly expected?: string;
+    readonly actual?: string;
+    readonly message?: string;
+}
+export interface RunSummary {
+    readonly total: number;
+    readonly passed: number;
+    readonly failed: number;
+    readonly skipped: number;
+    /** Cases whose family the adapter did not announce. */
+    readonly notRun: number;
+    readonly adapter?: {
+        readonly implementation?: string;
+        readonly version?: string;
+        readonly language?: string;
+        readonly families: readonly string[];
+    };
+    readonly outcomes: readonly CaseOutcome[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,5 @@
+// Shared types for the conformance manifest, the wire protocol between the
+// runner and an adapter, and the enumerated cases the runner drives. See
+// specs/security-protocol/rfc/0012-cross-language-conformance.md.
+export const CONFORMANCE_PROTOCOL_VERSION = 1;
+export const CONFORMANCE_MANIFEST_VERSION = 1;

package/fixtures/deployment-bundles-v1/README.md

@@ -0,0 +1,61 @@
+# Deployment bundle manifest v1 fixtures
+
+- `success.json` contains complete manifests accepted by the v1 validator.
+- `rejections.json` maps generated invalid inputs to stable failure codes.
+- `identity.json` fixes the RFC 8785 canonical bytes and domain-separated
+  SHA-256 identity for matching success fixture ids.
+
+The fixtures exercise RFC 0007. Artifact byte verification is covered by the
+CLI reference verifier because these language-neutral fixtures describe the
+manifest rather than a filesystem.
+
+## Generated rejection semantics
+
+Every rejection is a deterministic transform of this pinned base manifest
+(RFC 0012), where `artifact(index)` denotes (with `<sha256>` the 64-digit
+lowercase hexadecimal form of `index`, zero-padded):
+
+```json
+{
+  "runtime": "node",
+  "path": "artifacts/<sha256>.mjs",
+  "sha256": "<sha256>",
+  "byteLength": 1
+}
+```
+
+and the base is:
+
+```json
+{
+  "kind": "hypequery-deployment-bundle",
+  "version": 1,
+  "deployment": {
+    "path": "deployment.json",
+    "identity": "1111111111111111111111111111111111111111111111111111111111111111",
+    "sha256": "2222222222222222222222222222222222222222222222222222222222222222",
+    "byteLength": 1
+  },
+  "artifacts": [artifact(0)]
+}
+```
+
+Generator types expand as follows:
+
+- `wrong-root-type`: an empty array instead of an object;
+- `unknown-root-field`: the base plus `"extra": true`;
+- `unsupported-version`: the base with `"version": 2`;
+- `malformed-digest`: the base with `deployment.identity` replaced by
+  `"bad"`;
+- `traversal-path`: the base with `deployment.path` replaced by
+  `"../deployment.json"`;
+- `duplicate-path`: the base with its only artifact's `path` replaced by
+  `"deployment.json"`, colliding with the deployment path;
+- `too-many-artifacts`: the base with 101 artifacts `artifact(0)` through
+  `artifact(100)`;
+- `deployment-too-large`: the base with `deployment.byteLength` replaced by
+  16777217 (16 MiB plus one byte);
+- `unsafe-accessor`: the base with `kind` served by an enumerable computed
+  accessor returning `"hypequery-deployment-bundle"` instead of a plain
+  data property. Host-model conditional (RFC 0012): implementations whose
+  input model cannot express computed accessors skip this case.

package/fixtures/deployment-bundles-v1/identity.json

@@ -0,0 +1,7 @@
+[
+  {
+    "id": "node-runtime-bundle",
+    "canonical": "{\"artifacts\":[{\"byteLength\":2048,\"path\":\"artifacts/0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef.mjs\",\"runtime\":\"node\",\"sha256\":\"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\"}],\"deployment\":{\"byteLength\":1024,\"identity\":\"1111111111111111111111111111111111111111111111111111111111111111\",\"path\":\"deployment.json\",\"sha256\":\"2222222222222222222222222222222222222222222222222222222222222222\"},\"kind\":\"hypequery-deployment-bundle\",\"version\":1}",
+    "sha256": "fca7dcefbc455553890c2408d6a693d4583ec19cf0c055202930a03b41560ace"
+  }
+]

package/fixtures/deployment-bundles-v1/rejections.json

@@ -0,0 +1,11 @@
+[
+  { "id": "wrong-root-type", "generator": { "type": "wrong-root-type" }, "error": "HQ_BUNDLE_TYPE" },
+  { "id": "unknown-root-field", "generator": { "type": "unknown-root-field" }, "error": "HQ_BUNDLE_UNKNOWN_FIELD" },
+  { "id": "unsupported-version", "generator": { "type": "unsupported-version" }, "error": "HQ_BUNDLE_INVALID_VERSION" },
+  { "id": "malformed-digest", "generator": { "type": "malformed-digest" }, "error": "HQ_BUNDLE_INVALID_VALUE" },
+  { "id": "traversal-path", "generator": { "type": "traversal-path" }, "error": "HQ_BUNDLE_INVALID_PATH" },
+  { "id": "duplicate-path", "generator": { "type": "duplicate-path" }, "error": "HQ_BUNDLE_INVALID_REFERENCE" },
+  { "id": "too-many-artifacts", "generator": { "type": "too-many-artifacts" }, "error": "HQ_BUNDLE_TOO_MANY_ITEMS" },
+  { "id": "deployment-too-large", "generator": { "type": "deployment-too-large" }, "error": "HQ_BUNDLE_TOO_LARGE" },
+  { "id": "unsafe-accessor", "generator": { "type": "unsafe-accessor" }, "error": "HQ_BUNDLE_UNSAFE_OBJECT" }
+]

package/fixtures/deployment-bundles-v1/success.json

@@ -0,0 +1,23 @@
+[
+  {
+    "id": "node-runtime-bundle",
+    "value": {
+      "kind": "hypequery-deployment-bundle",
+      "version": 1,
+      "deployment": {
+        "path": "deployment.json",
+        "identity": "1111111111111111111111111111111111111111111111111111111111111111",
+        "sha256": "2222222222222222222222222222222222222222222222222222222222222222",
+        "byteLength": 1024
+      },
+      "artifacts": [
+        {
+          "runtime": "node",
+          "path": "artifacts/0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef.mjs",
+          "sha256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+          "byteLength": 2048
+        }
+      ]
+    }
+  }
+]

package/fixtures/deployment-releases-v1/README.md

@@ -0,0 +1,36 @@
+# Deployment release envelope v1 fixtures
+
+- `success.json` contains complete envelopes accepted by the v1 validator.
+- `rejections.json` maps generated invalid inputs to stable failure codes.
+- `identity.json` fixes the RFC 8785 canonical bytes and domain-separated
+  SHA-256 identity for matching success fixture ids.
+
+These fixtures exercise RFC 0008. Bundle filesystem verification remains part
+of RFC 0007 and is intentionally not duplicated here.
+
+## Generated rejection semantics
+
+Every rejection is a deterministic transform of this pinned base envelope
+(RFC 0012):
+
+```json
+{
+  "kind": "hypequery-deployment-release",
+  "version": 1,
+  "bundleIdentity": "0000000000000000000000000000000000000000000000000000000000000000",
+  "target": { "project": "project_1", "environment": "production" }
+}
+```
+
+Generator types expand as follows:
+
+- `wrong-root-type`: an empty array instead of an object;
+- `unknown-root-field`: the base plus `"extra": true`;
+- `unsupported-version`: the base with `"version": 2`;
+- `malformed-bundle-identity`: the base with `"bundleIdentity": "bad"`;
+- `target-too-large`: the base with `target.project` replaced by `p`
+  followed by 128 repetitions of `a` (129 bytes);
+- `unsafe-accessor`: the base with `kind` served by an enumerable computed
+  accessor returning `"hypequery-deployment-release"` instead of a plain
+  data property. Host-model conditional (RFC 0012): implementations whose
+  input model cannot express computed accessors skip this case.

package/fixtures/deployment-releases-v1/identity.json

@@ -0,0 +1,7 @@
+[
+  {
+    "id": "production-release",
+    "canonical": "{\"bundleIdentity\":\"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef\",\"kind\":\"hypequery-deployment-release\",\"target\":{\"environment\":\"production\",\"project\":\"prj_acme-analytics\"},\"version\":1}",
+    "sha256": "3ffb5ef6824431b6859c5ae609903e41abf3515c8080dff951dc4babfa2b6cda"
+  }
+]

package/fixtures/deployment-releases-v1/rejections.json

@@ -0,0 +1,8 @@
+[
+  { "id": "wrong-root-type", "generator": { "type": "wrong-root-type" }, "error": "HQ_RELEASE_TYPE" },
+  { "id": "unknown-root-field", "generator": { "type": "unknown-root-field" }, "error": "HQ_RELEASE_UNKNOWN_FIELD" },
+  { "id": "unsupported-version", "generator": { "type": "unsupported-version" }, "error": "HQ_RELEASE_INVALID_VERSION" },
+  { "id": "malformed-bundle-identity", "generator": { "type": "malformed-bundle-identity" }, "error": "HQ_RELEASE_INVALID_VALUE" },
+  { "id": "target-too-large", "generator": { "type": "target-too-large" }, "error": "HQ_RELEASE_TOO_LARGE" },
+  { "id": "unsafe-accessor", "generator": { "type": "unsafe-accessor" }, "error": "HQ_RELEASE_UNSAFE_OBJECT" }
+]

package/fixtures/deployment-releases-v1/success.json

@@ -0,0 +1,14 @@
+[
+  {
+    "id": "production-release",
+    "value": {
+      "kind": "hypequery-deployment-release",
+      "version": 1,
+      "bundleIdentity": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+      "target": {
+        "project": "prj_acme-analytics",
+        "environment": "production"
+      }
+    }
+  }
+]