@hypequery/protocol 0.19.0 → 0.21.0

package/dist/deployments/validate.js

@@ -1,6 +1,8 @@
 import { ProtocolExpressionError, validateProtocolExpression } from '../expressions/index.js';
 import { ProtocolIdentifierError, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, } from '../identifiers/index.js';
+import { ProtocolQueryImplementationError } from '../query-implementations/errors.js';
 import { validateProtocolSqlExpression } from '../sql-expressions/validate.js';
+import { attempt, collectErrors } from './collect.js';
 import { deploymentError } from './errors.js';
 import { expressionReferences, isSegmentPredicate, isSegmentReference } from './segments.js';
 import { resolveDeploymentLimits } from './limits.js';
@@ -62,15 +64,15 @@ function requireArray(input, path, maxItems) {
     }
     return input;
 }
-function exactFields(value, required, optional, path) {
+function exactFields(value, required, optional, path, issues) {
     const allowed = new Set([...required, ...optional]);
     for (const key of Object.keys(value)) {
         if (!allowed.has(key))
-            deploymentError('HQ_DEPLOYMENT_UNKNOWN_FIELD', `${path}.${key}`);
+            attempt(issues, () => deploymentError('HQ_DEPLOYMENT_UNKNOWN_FIELD', `${path}.${key}`));
     }
     for (const key of required) {
         if (!Object.hasOwn(value, key))
-            deploymentError('HQ_DEPLOYMENT_TYPE', `${path}.${key}`);
+            attempt(issues, () => deploymentError('HQ_DEPLOYMENT_TYPE', `${path}.${key}`));
     }
 }
 function freezeRecord(entries) {
@@ -119,28 +121,35 @@ function uniqueStrings(input, path, maxItems, parse) {
         deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', path);
     return Object.freeze(result);
 }
-function validateSemanticMetadata(value, result, path, limits) {
+function validateSemanticMetadata(value, result, path, limits, issues) {
     const parseText = (item, itemPath) => (boundedText(item, itemPath, limits.maxTextBytes));
+    // Each metadata field is independent, so each is its own recovery point.
     for (const key of ['examples', 'synonyms']) {
         if (value[key] !== undefined) {
-            result[key] = uniqueStrings(value[key], `${path}.${key}`, limits.maxSemanticMetadataItems, parseText);
+            attempt(issues, () => {
+                result[key] = uniqueStrings(value[key], `${path}.${key}`, limits.maxSemanticMetadataItems, parseText);
+            });
         }
     }
     for (const key of ['format', 'unit', 'timezone']) {
-        optionalText(value[key], key, result, path, limits);
+        attempt(issues, () => optionalText(value[key], key, result, path, limits));
     }
     if (value.currency !== undefined) {
-        const currency = boundedText(value.currency, `${path}.currency`, limits.maxTextBytes);
-        if (!/^[A-Z]{3}$/.test(currency)) {
-            deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', `${path}.currency`);
-        }
-        result.currency = currency;
+        attempt(issues, () => {
+            const currency = boundedText(value.currency, `${path}.currency`, limits.maxTextBytes);
+            if (!/^[A-Z]{3}$/.test(currency)) {
+                deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', `${path}.currency`);
+            }
+            result.currency = currency;
+        });
     }
     if (value.sensitivity !== undefined) {
-        if (typeof value.sensitivity !== 'string' || !SENSITIVITIES.has(value.sensitivity)) {
-            deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', `${path}.sensitivity`);
-        }
-        result.sensitivity = value.sensitivity;
+        attempt(issues, () => {
+            if (typeof value.sensitivity !== 'string' || !SENSITIVITIES.has(value.sensitivity)) {
+                deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', `${path}.sensitivity`);
+            }
+            result.sensitivity = value.sensitivity;
+        });
     }
 }
 function validateAccess(input, path, limits) {
@@ -230,6 +239,11 @@ function nested(action, path) {
         if (error instanceof ProtocolExpressionError) {
             deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', path);
         }
+        // RFC 0006 keeps the SQL envelope's own code; only the location is rebased
+        // from the envelope root onto the contract.
+        if (error instanceof ProtocolQueryImplementationError) {
+            throw new ProtocolQueryImplementationError(error.code, `${path}${error.path.slice(1)}`);
+        }
         throw error;
     }
 }
@@ -601,8 +615,12 @@ function validateDefaults(input, path, limits, version) {
     }
     return freezeRecord(result);
 }
-function namedItems(input, path, maxItems, validate) {
-    const items = requireArray(input, path, maxItems).map((value, index) => validate(value, `${path}[${index}]`, index));
+function namedItems(input, path, maxItems, validate, issues) {
+    const since = issues?.count ?? 0;
+    const items = requireArray(input, path, maxItems)
+        .map((value, index) => attempt(issues, () => validate(value, `${path}[${index}]`, index)));
+    // Name checks over a partial list would report the failed items again.
+    issues?.checkpoint(since);
     if (new Set(items.map(item => item.name)).size !== items.length) {
         deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', path);
     }
@@ -623,7 +641,9 @@ function validateSegment(input, path, limits, dimensions, tenant) {
     validateSemanticMetadata(value, result, path, limits);
     return freezeRecord(result);
 }
-function validateDataset(input, path, limits, measureIndices, version = 2) {
+function validateDataset(input, path, limits, measureIndices, version = 2, issues) {
+    const since = issues?.count ?? 0;
+    const field = (action) => attempt(issues, action);
     const value = requireRecord(input, path);
     // Contract 3 renames the allow-list; the old name is then an unknown field.
     const filtersKey = version === 3 ? 'allowedFilters' : 'filters';
@@ -634,57 +654,73 @@ function validateDataset(input, path, limits, measureIndices, version = 2) {
         ...SEMANTIC_METADATA_FIELDS,
         'timeField', 'limits', 'endpoint',
         ...(version === 3 ? ['segments'] : []),
-    ], path);
+    ], path, issues);
+    // Each field is a recovery point when collecting; without a collector
+    // `field` is a plain call and the first failure throws.
     const result = {
-        name: identifier(value.name, `${path}.name`),
-        source: boundedText(value.source, `${path}.source`, limits.maxSourceBytes),
-        tenant: validateTenant(value.tenant, `${path}.tenant`, limits),
-        dimensions: namedItems(value.dimensions, `${path}.dimensions`, limits.maxDatasetItems, (item, itemPath) => validateDimension(item, itemPath, limits)),
-        measures: namedItems(value.measures, `${path}.measures`, limits.maxDatasetItems, (item, itemPath, index) => validateMeasure(item, measureIndices === undefined ? itemPath : `${path}.measures[${measureIndices[index]}]`, limits, version)),
-        [filtersKey]: namedItems(value[filtersKey], `${path}.${filtersKey}`, limits.maxDatasetItems, (item, itemPath) => validateFilter(item, itemPath, limits)),
-        metrics: namedItems(value.metrics, `${path}.metrics`, limits.maxDatasetItems, (item, itemPath) => validateMetric(item, itemPath, limits)),
-        relationships: namedItems(value.relationships, `${path}.relationships`, limits.maxDatasetItems, (item, itemPath) => validateRelationship(item, itemPath, limits)),
+        name: field(() => identifier(value.name, `${path}.name`)),
+        source: field(() => boundedText(value.source, `${path}.source`, limits.maxSourceBytes)),
+        tenant: field(() => validateTenant(value.tenant, `${path}.tenant`, limits)),
+        dimensions: field(() => namedItems(value.dimensions, `${path}.dimensions`, limits.maxDatasetItems, (item, itemPath) => validateDimension(item, itemPath, limits), issues)),
+        measures: field(() => namedItems(value.measures, `${path}.measures`, limits.maxDatasetItems, (item, itemPath, index) => validateMeasure(item, measureIndices === undefined ? itemPath : `${path}.measures[${measureIndices[index]}]`, limits, version), issues)),
+        [filtersKey]: field(() => namedItems(value[filtersKey], `${path}.${filtersKey}`, limits.maxDatasetItems, (item, itemPath) => validateFilter(item, itemPath, limits), issues)),
+        metrics: field(() => namedItems(value.metrics, `${path}.metrics`, limits.maxDatasetItems, (item, itemPath) => validateMetric(item, itemPath, limits), issues)),
+        relationships: field(() => namedItems(value.relationships, `${path}.relationships`, limits.maxDatasetItems, (item, itemPath) => validateRelationship(item, itemPath, limits), issues)),
     };
-    if (version === 3 && value.segments !== undefined) {
-        result.segments = namedItems(value.segments, `${path}.segments`, limits.maxDatasetItems, (item, itemPath) => validateSegment(item, itemPath, limits, result.dimensions, result.tenant));
+    // Segments resolve against the dimensions and tenant, so they wait for both.
+    if (version === 3 && value.segments !== undefined
+        && result.dimensions !== undefined && result.tenant !== undefined) {
+        result.segments = field(() => namedItems(value.segments, `${path}.segments`, limits.maxDatasetItems, (item, itemPath) => validateSegment(item, itemPath, limits, result.dimensions, result.tenant), issues));
     }
-    if (value.timeField !== undefined)
-        result.timeField = identifier(value.timeField, `${path}.timeField`, true);
-    optionalText(value.description, 'description', result, path, limits);
-    optionalText(value.owner, 'owner', result, path, limits);
-    validateSemanticMetadata(value, result, path, limits);
+    if (value.timeField !== undefined) {
+        result.timeField = field(() => identifier(value.timeField, `${path}.timeField`, true));
+    }
+    field(() => optionalText(value.description, 'description', result, path, limits));
+    field(() => optionalText(value.owner, 'owner', result, path, limits));
+    validateSemanticMetadata(value, result, path, limits, issues);
     if (value.freshness !== undefined) {
-        result.freshness = validateFreshness(value.freshness, `${path}.freshness`);
+        result.freshness = field(() => validateFreshness(value.freshness, `${path}.freshness`));
     }
     if (value.defaults !== undefined) {
-        result.defaults = validateDefaults(value.defaults, `${path}.defaults`, limits, version);
+        result.defaults = field(() => validateDefaults(value.defaults, `${path}.defaults`, limits, version));
     }
     if (value.limits !== undefined)
-        result.limits = validateLimits(value.limits, `${path}.limits`);
-    if (value.endpoint !== undefined)
-        result.endpoint = validateEndpoint(value.endpoint, `${path}.endpoint`, limits);
+        result.limits = field(() => validateLimits(value.limits, `${path}.limits`));
+    if (value.endpoint !== undefined) {
+        result.endpoint = field(() => validateEndpoint(value.endpoint, `${path}.endpoint`, limits));
+    }
+    issues?.checkpoint(since);
     return freezeRecord(result);
 }
 export function validateProtocolDatasetContract(input, options = {}) {
     return validateDataset(input, '$', resolveDeploymentLimits(options));
 }
-function validateDatasetReferences(datasets) {
+/**
+ * Check a dataset contract and report every failure found, instead of
+ * throwing the first. Accepts exactly what `validateProtocolDatasetContract` accepts.
+ */
+export function checkProtocolDatasetContract(input, options = {}) {
+    const limits = resolveDeploymentLimits(options);
+    return collectErrors(issues => validateDataset(input, '$', limits, undefined, 2, issues));
+}
+function validateDatasetReferences(datasets, issues) {
     const names = new Set(datasets.map(dataset => dataset.name));
+    const reference = (path) => attempt(issues, () => deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', path));
     for (const [index, dataset] of datasets.entries()) {
         if (dataset.defaults?.dimensions?.some(name => (!dataset.dimensions.some(dimension => dimension.name === name && dimension.groupable)))) {
-            deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', `$.datasets[${index}].defaults.dimensions`);
+            reference(`$.datasets[${index}].defaults.dimensions`);
         }
         if (dataset.defaults?.timeGrain !== undefined && dataset.timeField === undefined) {
-            deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', `$.datasets[${index}].defaults.timeGrain`);
+            reference(`$.datasets[${index}].defaults.timeGrain`);
         }
         for (const [relationshipIndex, relationship] of dataset.relationships.entries()) {
             if (!names.has(relationship.target)) {
-                deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', `$.datasets[${index}].relationships[${relationshipIndex}].target`);
+                reference(`$.datasets[${index}].relationships[${relationshipIndex}].target`);
             }
         }
         if (dataset.endpoint !== undefined
             && (dataset.tenant.kind === 'required') !== (dataset.endpoint.tenant.kind === 'required')) {
-            deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', `$.datasets[${index}].endpoint.tenant`);
+            reference(`$.datasets[${index}].endpoint.tenant`);
         }
     }
 }
@@ -817,7 +853,8 @@ function validateTimeMeasure(value, path, limits) {
     validateSemanticMetadata(value, result, path, limits);
     return freezeRecord(result);
 }
-function validateDeploymentDataset(input, path, limits, version = 2) {
+function validateDeploymentDataset(input, path, limits, version = 2, issues) {
+    const since = issues?.count ?? 0;
     const value = requireRecord(input, path);
     exactFields(value, [
         'name', 'source', 'tenant', 'dimensions', 'measures',
@@ -826,80 +863,131 @@ function validateDeploymentDataset(input, path, limits, version = 2) {
         'description', 'freshness', 'owner', 'defaults',
         ...SEMANTIC_METADATA_FIELDS, 'timeField', 'limits', 'endpoint',
         ...(version === 3 ? ['segments'] : []),
-    ], path);
-    const measures = requireArray(value.measures, `${path}.measures`, limits.maxDatasetItems)
-        .map((measure, index) => requireRecord(measure, `${path}.measures[${index}]`));
+    ], path, issues);
+    // When collecting, a malformed measure list is reported and the rest of the
+    // dataset is still checked as if it had no measures; a malformed measure is
+    // reported and its siblings are still checked.
+    const records = attempt(issues, () => requireArray(value.measures, `${path}.measures`, limits.maxDatasetItems)) ?? [];
+    const checked = records.map((measure, index) => (attempt(issues, () => requireRecord(measure, `${path}.measures[${index}]`))));
     // Base measures are validated by the dataset; composite ones (derived, and in
     // contract 3 window and shift) reference them and are validated here.
     const isComposite = (measure) => measure.kind === 'derived'
         || (version === 3 && (measure.kind === 'window' || measure.kind === 'shift'));
     // Preserve original indices when validating base measures separately.
-    const baseEntries = measures.flatMap((measure, index) => (isComposite(measure) ? [] : [{ measure, index }]));
-    const validated = validateDataset({ ...value, measures: baseEntries.map(entry => entry.measure), metrics: [] }, path, limits, baseEntries.map(entry => entry.index), version);
-    const composite = measures.map((measure, index) => {
+    const baseEntries = checked.flatMap((measure, index) => (measure === undefined || isComposite(measure) ? [] : [{ measure, index }]));
+    const validated = attempt(issues, () => validateDataset({ ...value, measures: baseEntries.map(entry => entry.measure), metrics: [] }, path, limits, baseEntries.map(entry => entry.index), version, issues));
+    const composite = checked.map((measure, index) => measure && attempt(issues, () => {
         const measurePath = `${path}.measures[${index}]`;
         if (measure.kind === 'derived') {
             return validateDatasetDerivedMeasure(measure, measurePath, limits, version);
         }
         return isComposite(measure) ? validateTimeMeasure(measure, measurePath, limits) : undefined;
-    });
+    }));
+    // Cross-measure checks below assume every measure validated.
+    issues?.checkpoint(since);
+    const measures = checked;
+    // Independent cross-measure checks each recover; a check that needs a
+    // reference that failed is skipped rather than reported again.
+    const fail = (code, at) => attempt(issues, () => deploymentError(code, at));
     const derived = composite.map(item => (item?.kind === 'derived' ? item : undefined));
     const baseByName = new Map(validated.measures.map(measure => [measure.name, measure]));
     let baseIndex = 0;
     const ordered = measures.map((_, index) => (composite[index] ?? validated.measures[baseIndex++]));
     if (new Set(ordered.map(measure => measure.name)).size !== measures.length) {
-        deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', `${path}.measures`);
+        fail('HQ_DEPLOYMENT_INVALID_REFERENCE', `${path}.measures`);
     }
+    // Checks by name are ambiguous while names repeat.
+    issues?.checkpoint(since);
     const isApproximate = (measure) => measure?.approximate === true;
     // A time measure wraps exactly one base measure and needs the dataset's time axis.
     const timeByName = new Map();
+    // Time measures that failed a check still resolve by name, but checks that
+    // read their properties would only repeat that failure.
+    const failedTime = new Set();
     for (const [index, item] of composite.entries()) {
         if (!item || item.kind === 'derived')
             continue;
         const timeMeasure = item;
+        const before = issues?.count ?? 0;
         const measurePath = `${path}.measures[${index}]`;
         const wrapped = baseByName.get(timeMeasure.measure);
         if (!wrapped)
-            deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', `${measurePath}.measure`);
+            fail('HQ_DEPLOYMENT_INVALID_REFERENCE', `${measurePath}.measure`);
         if (validated.timeField === undefined)
-            deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', `${measurePath}.kind`);
-        if (timeMeasure.cumulative === true && !CUMULATIVE_AGGREGATIONS.has(wrapped.aggregation)) {
-            deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', `${measurePath}.cumulative`);
-        }
-        if (isApproximate(wrapped) !== isApproximate(timeMeasure)) {
-            deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', `${measurePath}.approximate`);
+            fail('HQ_DEPLOYMENT_INVALID_REFERENCE', `${measurePath}.kind`);
+        if (wrapped) {
+            if (timeMeasure.cumulative === true && !CUMULATIVE_AGGREGATIONS.has(wrapped.aggregation)) {
+                fail('HQ_DEPLOYMENT_INVALID_VALUE', `${measurePath}.cumulative`);
+            }
+            if (isApproximate(wrapped) !== isApproximate(timeMeasure)) {
+                fail('HQ_DEPLOYMENT_INVALID_VALUE', `${measurePath}.approximate`);
+            }
         }
         timeByName.set(timeMeasure.name, timeMeasure);
+        if ((issues?.count ?? 0) > before)
+            failedTime.add(timeMeasure.name);
     }
     for (const [index, item] of derived.entries()) {
         if (!item)
             continue;
+        let resolved = true;
         for (const [useIndex, use] of item.uses.entries()) {
             if (!baseByName.has(use.measure) && !timeByName.has(use.measure)) {
-                deploymentError('HQ_DEPLOYMENT_INVALID_REFERENCE', `${path}.measures[${index}].uses[${useIndex}].measure`);
+                resolved = false;
+                fail('HQ_DEPLOYMENT_INVALID_REFERENCE', `${path}.measures[${index}].uses[${useIndex}].measure`);
             }
         }
+        if (!resolved || item.uses.some(use => failedTime.has(use.measure)))
+            continue;
         const approximate = item.uses.some(use => (isApproximate(baseByName.get(use.measure) ?? timeByName.get(use.measure))));
         if (approximate !== isApproximate(item)) {
-            deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', `${path}.measures[${index}].approximate`);
+            fail('HQ_DEPLOYMENT_INVALID_VALUE', `${path}.measures[${index}].approximate`);
         }
     }
+    issues?.checkpoint(since);
     const { metrics: _metrics, ...dataset } = validated;
     return freezeRecord({ ...dataset, measures: Object.freeze(ordered) });
 }
+function validateContract(input, limits, version, issues) {
+    const value = requireRecord(input, '$');
+    exactFields(value, ['kind', 'version', 'datasets'], [], '$', issues);
+    attempt(issues, () => {
+        if (value.kind !== 'hypequery-deployment')
+            deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', '$.kind');
+    });
+    // Another version's rules do not apply, so its datasets are not worth checking.
+    const since = issues?.count ?? 0;
+    attempt(issues, () => {
+        if (value.version !== version)
+            deploymentError('HQ_DEPLOYMENT_INVALID_VERSION', '$.version');
+    });
+    issues?.checkpoint(since);
+    const datasets = attempt(issues, () => namedItems(value.datasets, '$.datasets', limits.maxDatasets, (item, path) => validateDeploymentDataset(item, path, limits, version, issues), issues));
+    // References between datasets need every dataset validated first.
+    issues?.checkpoint(0);
+    validateDatasetReferences(datasets, issues);
+    return datasets;
+}
 /** Validate the deployment contract. Unsupported fields are forbidden, even when empty. */
 export function validateProtocolDeploymentContract(input, options = {}) {
-    const limits = resolveDeploymentLimits(options);
-    const value = requireRecord(input, '$');
-    exactFields(value, ['kind', 'version', 'datasets'], [], '$');
-    if (value.kind !== 'hypequery-deployment')
-        deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', '$.kind');
-    if (value.version !== 2)
-        deploymentError('HQ_DEPLOYMENT_INVALID_VERSION', '$.version');
-    const datasets = namedItems(value.datasets, '$.datasets', limits.maxDatasets, (item, path) => validateDeploymentDataset(item, path, limits));
-    validateDatasetReferences(datasets);
+    return deploymentContract(validateContract(input, resolveDeploymentLimits(options), 2));
+}
+function deploymentContract(datasets) {
     return freezeRecord({ kind: 'hypequery-deployment', version: 2, datasets });
 }
+/**
+ * Check a deployment contract and report every failure found, instead of
+ * throwing the first. Accepts exactly what `validateProtocolDeploymentContract`
+ * accepts, and returns the same value when it does.
+ *
+ * Failures are reported per independent part of the contract (each dataset,
+ * collection item and dataset field). Checks that depend on a part that
+ * already failed are skipped so one mistake is not reported several times.
+ */
+export function checkProtocolDeploymentContract(input, options = {}) {
+    const limits = resolveDeploymentLimits(options);
+    return collectErrors(issues => deploymentContract(validateContract(input, limits, 2, issues)));
+}
 /** True when a contract 3 dataset uses anything contract 2 cannot express. */
 function usesContract3Feature(dataset) {
     return (dataset.segments?.length ?? 0) > 0
@@ -917,15 +1005,19 @@ function usesContract3Feature(dataset) {
  * function of its content rather than of which producer emitted it.
  */
 export function validateProtocolDeploymentContractV3(input, options = {}) {
+    return deploymentContractV3(validateContract(input, resolveDeploymentLimits(options), 3));
+}
+/**
+ * Check a deployment contract 3 and report every failure found, instead of
+ * throwing the first. Accepts exactly what `validateProtocolDeploymentContractV3`
+ * accepts; see `checkProtocolDeploymentContract` for how failures are grouped.
+ */
+export function checkProtocolDeploymentContractV3(input, options = {}) {
     const limits = resolveDeploymentLimits(options);
-    const value = requireRecord(input, '$');
-    exactFields(value, ['kind', 'version', 'datasets'], [], '$');
-    if (value.kind !== 'hypequery-deployment')
-        deploymentError('HQ_DEPLOYMENT_INVALID_VALUE', '$.kind');
-    if (value.version !== 3)
-        deploymentError('HQ_DEPLOYMENT_INVALID_VERSION', '$.version');
-    const datasets = namedItems(value.datasets, '$.datasets', limits.maxDatasets, (item, path) => validateDeploymentDataset(item, path, limits, 3));
-    validateDatasetReferences(datasets);
+    return collectErrors(issues => deploymentContractV3(validateContract(input, limits, 3, issues)));
+}
+function deploymentContractV3(validated) {
+    const datasets = validated;
     if (!datasets.some(usesContract3Feature)) {
         deploymentError('HQ_DEPLOYMENT_INVALID_VERSION', '$.version');
     }

package/dist/index.d.ts

@@ -19,8 +19,11 @@ export { DEFAULT_PROTOCOL_DEPLOYMENT_BUNDLE_LIMITS, PROTOCOL_DEPLOYMENT_BUNDLE_I
 export { DEFAULT_PROTOCOL_DEPLOYMENT_RELEASE_LIMITS, PROTOCOL_DEPLOYMENT_RELEASE_IDENTITY_DOMAIN, ProtocolDeploymentReleaseError, encodeProtocolDeploymentReleaseEnvelope, encodeProtocolDeploymentReleaseEnvelopeToString, hashProtocolDeploymentReleaseEnvelope, prepareProtocolDeploymentReleaseEnvelope, validateProtocolDeploymentReleaseEnvelope, validateProtocolDeploymentReleaseTarget, } from './releases/index.js';
 export type { PreparedProtocolDeploymentReleaseEnvelope, ProtocolDeploymentReleaseEnvelope, ProtocolDeploymentReleaseErrorCode, ProtocolDeploymentReleaseLimits, ProtocolDeploymentReleaseOptions, ProtocolDeploymentReleaseTarget, } from './releases/index.js';
 export type { PreparedProtocolDeploymentBundleManifest, ProtocolDeploymentBundleArtifact, ProtocolDeploymentBundleDeployment, ProtocolDeploymentBundleErrorCode, ProtocolDeploymentBundleFile, ProtocolDeploymentBundleLimits, ProtocolDeploymentBundleManifest, ProtocolDeploymentBundleOptions, } from './bundles/index.js';
-export { DEFAULT_PROTOCOL_DEPLOYMENT_LIMITS, PROTOCOL_DEPLOYMENT_IDENTITY_DOMAIN, PROTOCOL_DEPLOYMENT_V3_IDENTITY_DOMAIN, ProtocolDeploymentError, encodeProtocolDeploymentContract, encodeProtocolDeploymentContractToString, hashProtocolDeploymentContract, prepareProtocolDeploymentContract, prepareProtocolDeploymentContractV3, validateProtocolDatasetContract, validateProtocolDeploymentContract, validateProtocolDeploymentContractV3, } from './deployments/index.js';
-export type { ProtocolDatasetDerivedMeasure, ProtocolDeploymentDataset, ProtocolDeploymentMeasure, PreparedProtocolDeploymentContract, PreparedProtocolDeploymentContractV3, ProtocolAccessPolicy, ProtocolDatasetContract, ProtocolDatasetDefaults, ProtocolDatasetDimension, ProtocolDatasetFieldSource, ProtocolDatasetFieldType, ProtocolDatasetFilter, ProtocolDatasetFreshness, ProtocolDatasetLimits, ProtocolDatasetMeasure, ProtocolDatasetMetric, ProtocolDatasetRelationship, ProtocolDatasetTenantPolicy, ProtocolSemanticMetadata, ProtocolSemanticSensitivity, ProtocolDeploymentContract, ProtocolDeploymentContractV3, ProtocolDeploymentDatasetV3, ProtocolDeploymentMeasureV3, ProtocolDatasetDerivedMeasureV3, ProtocolDatasetMeasureV3, ProtocolDatasetSegment, ProtocolDatasetShiftMeasure, ProtocolDatasetWindowMeasure, ProtocolTimeInterval, ProtocolDeploymentErrorCode, ProtocolDeploymentLimits, ProtocolDeploymentOptions, ProtocolEndpointPolicy, ProtocolEndpointTenantPolicy, ProtocolMetricDerivation, ProtocolMetricInput, } from './deployments/index.js';
+export { DEFAULT_PROTOCOL_DEPLOYMENT_LIMITS, PROTOCOL_DEPLOYMENT_IDENTITY_DOMAIN, PROTOCOL_DEPLOYMENT_V3_IDENTITY_DOMAIN, ProtocolDeploymentError, checkProtocolDatasetContract, checkProtocolDeploymentContract, checkProtocolDeploymentContractV3, encodeProtocolDeploymentContract, encodeProtocolDeploymentContractToString, hashProtocolDeploymentContract, prepareProtocolDeploymentContract, prepareProtocolDeploymentContractV3, validateProtocolDatasetContract, validateProtocolDeploymentContract, validateProtocolDeploymentContractV3, } from './deployments/index.js';
+export type { ProtocolDatasetDerivedMeasure, ProtocolDeploymentDataset, ProtocolDeploymentMeasure, PreparedProtocolDeploymentContract, PreparedProtocolDeploymentContractV3, ProtocolAccessPolicy, ProtocolDatasetContract, ProtocolDatasetDefaults, ProtocolDatasetDimension, ProtocolDatasetFieldSource, ProtocolDatasetFieldType, ProtocolDatasetFilter, ProtocolDatasetFreshness, ProtocolDatasetLimits, ProtocolDatasetMeasure, ProtocolDatasetMetric, ProtocolDatasetRelationship, ProtocolDatasetTenantPolicy, ProtocolSemanticMetadata, ProtocolSemanticSensitivity, ProtocolDeploymentContract, ProtocolDeploymentContractV3, ProtocolDeploymentDatasetV3, ProtocolDeploymentMeasureV3, ProtocolDatasetDerivedMeasureV3, ProtocolDatasetMeasureV3, ProtocolDatasetSegment, ProtocolDatasetShiftMeasure, ProtocolDatasetWindowMeasure, ProtocolTimeInterval, ProtocolDeploymentCheckResult, ProtocolDeploymentErrorCode, ProtocolDeploymentValidationError, ProtocolDeploymentLimits, ProtocolDeploymentOptions, ProtocolEndpointPolicy, ProtocolEndpointTenantPolicy, ProtocolMetricDerivation, ProtocolMetricInput, } from './deployments/index.js';
 export type { ProtocolQueryImplementation, ProtocolQueryImplementationErrorCode, ProtocolQueryImplementationLimits, ProtocolQueryImplementationOptions, ProtocolSqlDialect, ProtocolSqlExpression, ProtocolSqlParameter, ProtocolSqlParameterSource, ProtocolSqlTenantPolicy, } from './query-implementations/index.js';
 export { PROTOCOL_SEMANTIC_FAILURE_MESSAGES } from './invocations/failure-messages.js';
+export * from './client-contract/index.js';
+export { PROTOCOL_FIELD_VISIBILITY_LIMITS, ProtocolFieldVisibilityError, resolveProtocolVisibleDatasetFields, validateProtocolFieldVisibility, } from './visibility/index.js';
+export type { ProtocolDatasetVisibility, ProtocolFieldVisibility, ProtocolFieldVisibilityErrorCode, ProtocolVisibleDatasetFields, ProtocolVisibleFields, } from './visibility/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -9,5 +9,7 @@ export { DEFAULT_PROTOCOL_QUERY_EVENT_LIMITS, ProtocolQueryDiagnosticsError, Pro
 export { DEFAULT_PROTOCOL_SEMANTIC_INVOCATION_LIMITS, ProtocolSemanticInvocationError, validateProtocolSemanticInvocation, validateProtocolSemanticInvocationFailure, validateProtocolSemanticInvocationResult, validateProtocolSemanticInvocationV2, } from './invocations/index.js';
 export { DEFAULT_PROTOCOL_DEPLOYMENT_BUNDLE_LIMITS, PROTOCOL_DEPLOYMENT_BUNDLE_IDENTITY_DOMAIN, ProtocolDeploymentBundleError, encodeProtocolDeploymentBundleManifest, encodeProtocolDeploymentBundleManifestToString, hashProtocolDeploymentBundleManifest, prepareProtocolDeploymentBundleManifest, validateProtocolDeploymentBundleManifest, } from './bundles/index.js';
 export { DEFAULT_PROTOCOL_DEPLOYMENT_RELEASE_LIMITS, PROTOCOL_DEPLOYMENT_RELEASE_IDENTITY_DOMAIN, ProtocolDeploymentReleaseError, encodeProtocolDeploymentReleaseEnvelope, encodeProtocolDeploymentReleaseEnvelopeToString, hashProtocolDeploymentReleaseEnvelope, prepareProtocolDeploymentReleaseEnvelope, validateProtocolDeploymentReleaseEnvelope, validateProtocolDeploymentReleaseTarget, } from './releases/index.js';
-export { DEFAULT_PROTOCOL_DEPLOYMENT_LIMITS, PROTOCOL_DEPLOYMENT_IDENTITY_DOMAIN, PROTOCOL_DEPLOYMENT_V3_IDENTITY_DOMAIN, ProtocolDeploymentError, encodeProtocolDeploymentContract, encodeProtocolDeploymentContractToString, hashProtocolDeploymentContract, prepareProtocolDeploymentContract, prepareProtocolDeploymentContractV3, validateProtocolDatasetContract, validateProtocolDeploymentContract, validateProtocolDeploymentContractV3, } from './deployments/index.js';
+export { DEFAULT_PROTOCOL_DEPLOYMENT_LIMITS, PROTOCOL_DEPLOYMENT_IDENTITY_DOMAIN, PROTOCOL_DEPLOYMENT_V3_IDENTITY_DOMAIN, ProtocolDeploymentError, checkProtocolDatasetContract, checkProtocolDeploymentContract, checkProtocolDeploymentContractV3, encodeProtocolDeploymentContract, encodeProtocolDeploymentContractToString, hashProtocolDeploymentContract, prepareProtocolDeploymentContract, prepareProtocolDeploymentContractV3, validateProtocolDatasetContract, validateProtocolDeploymentContract, validateProtocolDeploymentContractV3, } from './deployments/index.js';
 export { PROTOCOL_SEMANTIC_FAILURE_MESSAGES } from './invocations/failure-messages.js';
+export * from './client-contract/index.js';
+export { PROTOCOL_FIELD_VISIBILITY_LIMITS, ProtocolFieldVisibilityError, resolveProtocolVisibleDatasetFields, validateProtocolFieldVisibility, } from './visibility/index.js';

package/dist/releases/codec.js

@@ -1,5 +1,5 @@
-import { sha256 } from '@noble/hashes/sha2';
-import { bytesToHex } from '@noble/hashes/utils';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
 import { serializeJcs } from '../values/jcs.js';
 import { validateProtocolDeploymentReleaseEnvelope } from './validate.js';
 const textEncoder = new TextEncoder();

package/dist/values/codec.js

@@ -1,5 +1,5 @@
-import { sha256 } from '@noble/hashes/sha2';
-import { bytesToHex } from '@noble/hashes/utils';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
 import { valueError } from './errors.js';
 import { serializeJcs } from './jcs.js';
 import { resolveLimits } from './limits.js';

package/dist/visibility/errors.d.ts

@@ -0,0 +1,8 @@
+import type { ProtocolFieldVisibilityErrorCode } from './types.js';
+export declare class ProtocolFieldVisibilityError extends TypeError {
+    readonly code: ProtocolFieldVisibilityErrorCode;
+    readonly path: string;
+    constructor(code: ProtocolFieldVisibilityErrorCode, path?: string);
+}
+export declare function visibilityError(code: ProtocolFieldVisibilityErrorCode, path?: string): never;
+//# sourceMappingURL=errors.d.ts.map

package/dist/visibility/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/visibility/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,YAAY,CAAC;AAEnE,qBAAa,4BAA6B,SAAQ,SAAS;IACzD,QAAQ,CAAC,IAAI,EAAE,gCAAgC,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,gCAAgC,EAAE,IAAI,SAAM;CAM/D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,gCAAgC,EAAE,IAAI,SAAM,GAAG,KAAK,CAEzF"}

package/dist/visibility/errors.js

@@ -0,0 +1,13 @@
+export class ProtocolFieldVisibilityError extends TypeError {
+    code;
+    path;
+    constructor(code, path = '$') {
+        super(`${code} at ${path}`);
+        this.name = 'ProtocolFieldVisibilityError';
+        this.code = code;
+        this.path = path;
+    }
+}
+export function visibilityError(code, path = '$') {
+    throw new ProtocolFieldVisibilityError(code, path);
+}

package/dist/visibility/index.d.ts

@@ -0,0 +1,5 @@
+export { ProtocolFieldVisibilityError } from './errors.js';
+export { resolveProtocolVisibleDatasetFields } from './resolve.js';
+export { PROTOCOL_FIELD_VISIBILITY_LIMITS, validateProtocolFieldVisibility } from './validate.js';
+export type { ProtocolDatasetVisibility, ProtocolFieldVisibility, ProtocolFieldVisibilityErrorCode, ProtocolVisibleDatasetFields, ProtocolVisibleFields, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/visibility/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/visibility/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAE,mCAAmC,EAAE,MAAM,cAAc,CAAC;AACnE,OAAO,EAAE,gCAAgC,EAAE,+BAA+B,EAAE,MAAM,eAAe,CAAC;AAClG,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,gCAAgC,EAChC,4BAA4B,EAC5B,qBAAqB,GACtB,MAAM,YAAY,CAAC"}

package/dist/visibility/index.js

@@ -0,0 +1,3 @@
+export { ProtocolFieldVisibilityError } from './errors.js';
+export { resolveProtocolVisibleDatasetFields } from './resolve.js';
+export { PROTOCOL_FIELD_VISIBILITY_LIMITS, validateProtocolFieldVisibility } from './validate.js';

package/dist/visibility/resolve.d.ts

@@ -0,0 +1,30 @@
+import type { ProtocolDeploymentDataset } from '../deployments/index.js';
+import type { ProtocolFieldVisibility, ProtocolVisibleDatasetFields } from './types.js';
+/**
+ * What one dataset exposes under a visibility policy, or null when the policy
+ * hides the dataset (RFC 0019).
+ *
+ * Names the policy lists but the contract doesn't have are ignored, so a
+ * policy written against one release keeps working after a later release
+ * removes a field. Visibility only narrows: a dimension the contract marks
+ * non-groupable or non-filterable stays so.
+ *
+ * - A one-hop `relationship.dimension` is visible only when the target dataset
+ *   and that dimension are visible in the target's own entry, and the
+ *   relationship's local join keys are visible.
+ * - A declared filter is visible only when the dimension it filters is.
+ * - The time field is visible only as a visible dimension; grouping by period
+ *   and time measures need it.
+ * - A measure is visible only when it is listed and every measure it is
+ *   computed from is visible too. A derived ratio over a hidden measure would
+ *   let a caller recover the hidden value.
+ * - Measures are authorized by name, independently of the dimensions they
+ *   aggregate: `revenue = sum(amount)` stays visible with `amount` hidden. A
+ *   `min`, `max`, `argMax` or `countDistinct` over a hidden dimension reveals
+ *   its values, so list measures explicitly rather than use `*` when a dataset
+ *   has any that must stay hidden; `*` also exposes measures added later.
+ * - Segments are not narrowed. Deployment contract 2, which this resolves, has
+ *   none.
+ */
+export declare function resolveProtocolVisibleDatasetFields(dataset: ProtocolDeploymentDataset, datasets: ReadonlyMap<string, ProtocolDeploymentDataset>, visibility: ProtocolFieldVisibility): ProtocolVisibleDatasetFields | null;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/visibility/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/visibility/resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,KAAK,EACV,uBAAuB,EACvB,4BAA4B,EAE7B,MAAM,YAAY,CAAC;AA6CpB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,yBAAyB,EAClC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,yBAAyB,CAAC,EACxD,UAAU,EAAE,uBAAuB,GAClC,4BAA4B,GAAG,IAAI,CA+CrC"}