@hypequery/protocol-conformance 0.0.0-canary-20260722115402

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are advised to review the applicable
+      documentation for the specific language governing permissions and
+      limitations under each license.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 hypequery
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. 

package/README.md

@@ -0,0 +1,40 @@
+# @hypequery/protocol-conformance
+
+Cross-language conformance runner and TypeScript reference adapter for the
+Hypequery security protocol. It drives any implementation of the protocol
+against the language-neutral fixtures in `specs/security-protocol/fixtures/`
+and checks the results against the pinned expectations.
+
+See [RFC 0012](../../specs/security-protocol/rfc/0012-cross-language-conformance.md)
+for the manifest schema, the adapter wire protocol, and the pass criteria.
+
+## Usage
+
+```sh
+# Run the whole suite against the bundled TypeScript reference adapter.
+hypequery-protocol-conformance run -- hypequery-protocol-reference-adapter
+
+# Run against another implementation (any language). Everything after `--`
+# is the adapter command, spawned without a shell.
+hypequery-protocol-conformance run --fixtures ./fixtures -- python -m my_impl.adapter
+
+# Restrict to families, skip or isolate the fuzz corpus, emit JSON.
+hypequery-protocol-conformance run --families sql-portability-v1 --skip-fuzz \
+  --report json -- node ./adapter.mjs
+
+# List the enumerated case counts per family.
+hypequery-protocol-conformance list
+```
+
+Exit codes: `0` all cases passed, `1` conformance failures, `2` setup or
+protocol error.
+
+## Writing an adapter
+
+An adapter reads newline-delimited JSON on stdin and writes it on stdout. It
+answers a `hello` with the families it supports, then one `result` per `case`.
+The `createStdioAdapter` helper implements the loop; a handler maps
+`(family, role, case)` to `{ ok: true, output? }`, `{ ok: false, code }`, or
+`{ skipped: true, reason }`. The bundled fixture snapshot means a pinned
+package version is a pinned conformance target; pass `--fixtures` to test
+against newer or local specs.

package/dist/adapters/generators.d.ts

@@ -0,0 +1,13 @@
+type Spec = Record<string, unknown>;
+export declare function materializeTaggedValue(spec: Spec): unknown;
+export declare function materializeIdentifier(spec: Spec): string;
+export declare function materializeExpression(spec: Spec): unknown;
+export declare function materializeSchema(spec: Spec): unknown;
+export declare function materializeImplementation(spec: Spec): unknown;
+export declare function materializeEvent(spec: Spec): unknown;
+export declare function materializeDiagnostics(spec: Spec): unknown;
+export declare function materializeDeployment(spec: Spec): unknown;
+export declare function materializeBundle(spec: Spec): unknown;
+export declare function materializeRelease(spec: Spec): unknown;
+export {};
+//# sourceMappingURL=generators.d.ts.map

package/dist/adapters/generators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generators.d.ts","sourceRoot":"","sources":["../../src/adapters/generators.ts"],"names":[],"mappings":"AAIA,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAkBpC,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAyB1D;AAID,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAMxD;AAMD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAiCzD;AAID,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CA2BrD;AAgBD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAuB7D;AAkBD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAyBpD;AAeD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAoB1D;AA2BD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAwDzD;AAkBD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAmBrD;AAaD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAgBtD"}

package/dist/adapters/generators.js

@@ -0,0 +1,366 @@
+// Deterministic materialization of `generator` fixture cases, implemented from
+// the normative fixture-README semantics (RFC 0012). Each family's generators
+// mirror the transforms documented in its README; keep the two in lockstep.
+function repeat(value, count) {
+    return value.repeat(count);
+}
+function accessorObject(kind, property = 'kind') {
+    const object = {};
+    Object.defineProperty(object, property, { enumerable: true, get: () => kind });
+    return object;
+}
+// --- tagged-values-v1 (also used by the value-sources fuzz corpus) ---
+function taggedArray(values) {
+    return { $hypequery: { type: 'array', version: 1, values } };
+}
+export function materializeTaggedValue(spec) {
+    switch (spec.type) {
+        case 'nested-array': {
+            let value = spec.leaf;
+            for (let depth = 0; depth < spec.depth; depth += 1)
+                value = taggedArray([value]);
+            return value;
+        }
+        case 'array':
+            return taggedArray(Array.from({ length: spec.items }, () => spec.value));
+        case 'array-tree':
+            return taggedArray(Array.from({ length: spec.branches }, () => taggedArray(Array.from({ length: spec.itemsPerBranch }, () => spec.value))));
+        case 'non-finite-float':
+            if (spec.value === 'NaN')
+                return Number.NaN;
+            if (spec.value === 'Infinity')
+                return Number.POSITIVE_INFINITY;
+            if (spec.value === '-Infinity')
+                return Number.NEGATIVE_INFINITY;
+            throw new Error(`Unknown non-finite float: ${String(spec.value)}`);
+        case 'repeat-string':
+            return repeat(spec.utf8, spec.count);
+        default:
+            throw new Error(`Unknown tagged-value generator: ${String(spec.type)}`);
+    }
+}
+// --- identifiers-v1 ---
+export function materializeIdentifier(spec) {
+    if (spec.type === 'repeat-string')
+        return repeat(spec.value, spec.count);
+    if (spec.type === 'qualified-segments') {
+        return Array.from({ length: spec.count }, () => spec.segment).join('.');
+    }
+    throw new Error(`Unknown identifier generator: ${String(spec.type)}`);
+}
+// --- expressions-v1 ---
+const EXPR_LITERAL = { kind: 'literal', value: false };
+export function materializeExpression(spec) {
+    switch (spec.type) {
+        case 'nested-not': {
+            let value = EXPR_LITERAL;
+            for (let i = 0; i < spec.depth; i += 1) {
+                value = { kind: 'logical', operator: 'not', operand: value };
+            }
+            return value;
+        }
+        case 'logical-operands':
+            return {
+                kind: 'logical',
+                operator: 'and',
+                operands: Array.from({ length: spec.count }, () => ({ ...EXPR_LITERAL })),
+            };
+        case 'logical-tree':
+            return {
+                kind: 'logical',
+                operator: 'and',
+                operands: Array.from({ length: 10 }, () => ({
+                    kind: 'logical',
+                    operator: 'and',
+                    operands: Array.from({ length: 100 }, () => ({ ...EXPR_LITERAL })),
+                })),
+            };
+        case 'unsafe-accessor': {
+            const value = { kind: 'reference' };
+            Object.defineProperty(value, 'name', { enumerable: true, get: () => 'orders' });
+            return value;
+        }
+        default:
+            throw new Error(`Unknown expression generator: ${String(spec.type)}`);
+    }
+}
+// --- query-schemas-v1 ---
+export function materializeSchema(spec) {
+    switch (spec.type) {
+        case 'nested-array': {
+            let value = { kind: 'any' };
+            for (let i = 0; i < spec.depth; i += 1)
+                value = { kind: 'array', items: value };
+            return value;
+        }
+        case 'union-tree':
+            return {
+                kind: 'union',
+                variants: Array.from({ length: 10 }, () => ({
+                    kind: 'union',
+                    variants: Array.from({ length: 100 }, () => ({ kind: 'any' })),
+                })),
+            };
+        case 'enum-values':
+            return {
+                kind: 'enum',
+                values: Array.from({ length: spec.count }, (_, i) => `v${i}`),
+            };
+        case 'description':
+            return { kind: 'string', description: repeat('a', spec.bytes) };
+        case 'unsafe-accessor':
+            return accessorObject('string');
+        default:
+            throw new Error(`Unknown schema generator: ${String(spec.type)}`);
+    }
+}
+// --- query-implementations-v1 ---
+function compiledSql(parameters) {
+    return {
+        kind: 'compiled-sql',
+        dialect: 'clickhouse',
+        operation: 'select',
+        statement: 'SELECT 1',
+        parameters,
+        readSources: [],
+        tenant: { kind: 'not-required' },
+    };
+}
+export function materializeImplementation(spec) {
+    switch (spec.type) {
+        case 'parameters':
+            return compiledSql(Array.from({ length: spec.count }, (_, i) => ({
+                name: `param${i}`,
+                source: { kind: 'input', path: `param${i}` },
+                clickHouseType: 'String',
+            })));
+        case 'sql-expression':
+            return {
+                kind: 'sql-expression',
+                dialect: 'clickhouse',
+                sql: repeat('a', spec.bytes),
+                output: { kind: 'string' },
+                dependencies: [],
+            };
+        case 'unsafe-accessor':
+            return accessorObject('semantic-plan');
+        default:
+            throw new Error(`Unknown implementation generator: ${String(spec.type)}`);
+    }
+}
+// --- query-events-v1 ---
+function baseEvent() {
+    return {
+        kind: 'hypequery-query-event',
+        version: 1,
+        eventId: '0'.repeat(64),
+        occurredAt: '2026-07-20T12:34:56.789Z',
+        target: { project: 'project_1', environment: 'production' },
+        queryName: 'daily_revenue',
+        operation: 'query',
+        outcome: 'success',
+        durationMs: 182,
+    };
+}
+export function materializeEvent(spec) {
+    const value = baseEvent();
+    switch (spec.type) {
+        case 'wrong-root-type': return [];
+        case 'missing-required-field': {
+            delete value.durationMs;
+            return value;
+        }
+        case 'unknown-sql-field': return { ...value, sql: 'SELECT 1' };
+        case 'unknown-parameters-field': return { ...value, parameters: { start: '2026-01-01' } };
+        case 'unknown-raw-tenant-field': return { ...value, tenantId: 'acme' };
+        case 'newer-version': return { ...value, version: 2 };
+        case 'malformed-event-id': return { ...value, eventId: 'bad' };
+        case 'invalid-occurred-at': return { ...value, occurredAt: '2026-13-40T99:99:99Z' };
+        case 'failure-without-category': return { ...value, outcome: 'failure' };
+        case 'success-with-category': return { ...value, errorCategory: 'internal' };
+        case 'unknown-error-category': return { ...value, outcome: 'failure', errorCategory: 'exploded' };
+        case 'negative-duration': return { ...value, durationMs: -1 };
+        case 'invalid-target': return { ...value, target: { project: 'has space', environment: 'production' } };
+        case 'invalid-query-name': return { ...value, queryName: 'not an identifier' };
+        case 'oversized-correlation-id': return { ...value, correlationId: repeat('x', 2_049) };
+        case 'unsafe-accessor': {
+            const unsafe = baseEvent();
+            Object.defineProperty(unsafe, 'kind', { enumerable: true, get: () => 'hypequery-query-event' });
+            return unsafe;
+        }
+        default: throw new Error(`Unknown event generator: ${String(spec.type)}`);
+    }
+}
+// --- query-diagnostics-v1 ---
+function baseDiagnostics() {
+    return {
+        kind: 'hypequery-query-diagnostics',
+        version: 1,
+        eventId: '0'.repeat(64),
+        queryId: '1'.repeat(64),
+        terminalReason: 'completed',
+        attempts: 1,
+    };
+}
+export function materializeDiagnostics(spec) {
+    const value = baseDiagnostics();
+    switch (spec.type) {
+        case 'wrong-root-type': return [];
+        case 'missing-required-field': {
+            delete value.attempts;
+            return value;
+        }
+        case 'unknown-result-field': return { ...value, rows: [[1, 2]] };
+        case 'unknown-credentials-field': return { ...value, password: 'hunter2' };
+        case 'newer-version': return { ...value, version: 2 };
+        case 'malformed-query-id': return { ...value, queryId: 'bad' };
+        case 'unknown-terminal-reason': return { ...value, terminalReason: 'exploded' };
+        case 'zero-attempts': return { ...value, attempts: 0 };
+        case 'control-character-message': return { ...value, safeMessage: 'bad\u0007message' };
+        case 'oversized-debug-query': return { ...value, debugQuery: repeat('x', 4_097) };
+        case 'unsafe-accessor': {
+            const unsafe = baseDiagnostics();
+            Object.defineProperty(unsafe, 'kind', { enumerable: true, get: () => 'hypequery-query-diagnostics' });
+            return unsafe;
+        }
+        default: throw new Error(`Unknown diagnostics generator: ${String(spec.type)}`);
+    }
+}
+// --- deployments-v1 ---
+function minimalDataset(name = 'orders') {
+    return {
+        name,
+        source: 'orders',
+        tenant: { kind: 'not-required' },
+        dimensions: [],
+        measures: [],
+        filters: [],
+        metrics: [],
+        relationships: [],
+    };
+}
+function baseDeployment() {
+    return {
+        kind: 'hypequery-deployment',
+        version: 1,
+        datasets: [minimalDataset()],
+        queries: [],
+        artifacts: [],
+    };
+}
+export function materializeDeployment(spec) {
+    const value = baseDeployment();
+    switch (spec.type) {
+        case 'wrong-root-type': return [];
+        case 'unknown-root-field': return { ...value, extra: true };
+        case 'unsupported-version': return { ...value, version: 2 };
+        case 'invalid-dataset-identifier': return { ...value, datasets: [minimalDataset('bad-name')] };
+        case 'invalid-relationship-queryability':
+            return {
+                ...value,
+                datasets: [{
+                        ...minimalDataset(),
+                        relationships: [{
+                                name: 'items', kind: 'hasMany', target: 'orders', from: 'id', to: 'order_id', queryable: true,
+                            }],
+                    }],
+            };
+        case 'missing-runtime-artifact':
+            return {
+                ...value,
+                queries: [{
+                        name: 'health',
+                        input: { kind: 'any' },
+                        output: { kind: 'any' },
+                        implementation: {
+                            kind: 'runtime-reference', runtime: 'node', artifactSha256: '0'.repeat(64), entrypoint: 'queries.health',
+                        },
+                        endpoint: { access: { kind: 'public' }, tenant: { kind: 'not-required' }, method: 'GET', path: '/health' },
+                        tags: [],
+                    }],
+            };
+        case 'ambiguous-query-route': {
+            const namedQuery = (name) => ({
+                name,
+                input: { kind: 'void' },
+                output: { kind: 'void' },
+                implementation: {
+                    kind: 'semantic-plan',
+                    query: { kind: 'dataset', dataset: 'orders', dimensions: [], measures: [], filters: [], orderBy: [] },
+                },
+                endpoint: { access: { kind: 'public' }, tenant: { kind: 'not-required' }, method: 'GET', path: '/same' },
+                tags: [],
+            });
+            return { ...value, queries: [namedQuery('first'), namedQuery('second')] };
+        }
+        case 'too-many-datasets':
+            return { ...value, datasets: Array.from({ length: 101 }, (_, i) => minimalDataset(`dataset_${i}`)) };
+        case 'source-too-large':
+            return { ...value, datasets: [{ ...minimalDataset(), source: repeat('a', 1_025) }] };
+        case 'unsafe-accessor': {
+            const unsafe = baseDeployment();
+            Object.defineProperty(unsafe, 'kind', { enumerable: true, get: () => 'hypequery-deployment' });
+            return unsafe;
+        }
+        default: throw new Error(`Unknown deployment generator: ${String(spec.type)}`);
+    }
+}
+// --- deployment-bundles-v1 ---
+function bundleArtifact(index = 0) {
+    const sha256 = index.toString(16).padStart(64, '0');
+    return { runtime: 'node', path: `artifacts/${sha256}.mjs`, sha256, byteLength: 1 };
+}
+function baseManifest() {
+    return {
+        kind: 'hypequery-deployment-bundle',
+        version: 1,
+        deployment: { path: 'deployment.json', identity: '1'.repeat(64), sha256: '2'.repeat(64), byteLength: 1 },
+        artifacts: [bundleArtifact()],
+    };
+}
+export function materializeBundle(spec) {
+    const value = baseManifest();
+    const deployment = value.deployment;
+    switch (spec.type) {
+        case 'wrong-root-type': return [];
+        case 'unknown-root-field': return { ...value, extra: true };
+        case 'unsupported-version': return { ...value, version: 2 };
+        case 'malformed-digest': return { ...value, deployment: { ...deployment, identity: 'bad' } };
+        case 'traversal-path': return { ...value, deployment: { ...deployment, path: '../deployment.json' } };
+        case 'duplicate-path': return { ...value, artifacts: [{ ...bundleArtifact(), path: deployment.path }] };
+        case 'too-many-artifacts': return { ...value, artifacts: Array.from({ length: 101 }, (_, i) => bundleArtifact(i)) };
+        case 'deployment-too-large': return { ...value, deployment: { ...deployment, byteLength: (16 * 1024 * 1024) + 1 } };
+        case 'unsafe-accessor': {
+            const unsafe = baseManifest();
+            Object.defineProperty(unsafe, 'kind', { enumerable: true, get: () => 'hypequery-deployment-bundle' });
+            return unsafe;
+        }
+        default: throw new Error(`Unknown bundle generator: ${String(spec.type)}`);
+    }
+}
+// --- deployment-releases-v1 ---
+function baseRelease() {
+    return {
+        kind: 'hypequery-deployment-release',
+        version: 1,
+        bundleIdentity: '0'.repeat(64),
+        target: { project: 'project_1', environment: 'production' },
+    };
+}
+export function materializeRelease(spec) {
+    const value = baseRelease();
+    const target = value.target;
+    switch (spec.type) {
+        case 'wrong-root-type': return [];
+        case 'unknown-root-field': return { ...value, extra: true };
+        case 'unsupported-version': return { ...value, version: 2 };
+        case 'malformed-bundle-identity': return { ...value, bundleIdentity: 'bad' };
+        case 'target-too-large': return { ...value, target: { ...target, project: `p${repeat('a', 128)}` } };
+        case 'unsafe-accessor': {
+            const unsafe = baseRelease();
+            Object.defineProperty(unsafe, 'kind', { enumerable: true, get: () => 'hypequery-deployment-release' });
+            return unsafe;
+        }
+        default: throw new Error(`Unknown release generator: ${String(spec.type)}`);
+    }
+}

package/dist/adapters/reference.d.ts

@@ -0,0 +1,6 @@
+import type { FixtureRole, HandlerResult } from '../types.js';
+type Case = Record<string, unknown>;
+export declare const REFERENCE_FAMILIES: readonly ["tagged-values-v1", "identifiers-v1", "expressions-v1", "query-schemas-v1", "query-implementations-v1", "query-events-v1", "query-diagnostics-v1", "deployments-v1", "deployment-bundles-v1", "deployment-releases-v1"];
+export declare function referenceHandle(family: string, role: FixtureRole, c: Case, section?: string): HandlerResult;
+export {};
+//# sourceMappingURL=reference.d.ts.map

package/dist/adapters/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../src/adapters/reference.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAc9D,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA0BpC,eAAO,MAAM,kBAAkB,mOAWrB,CAAC;AAEX,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,WAAW,EACjB,CAAC,EAAE,IAAI,EACP,OAAO,CAAC,EAAE,MAAM,GACf,aAAa,CAkCf"}