@hypequery/protocol 0.0.0-canary-20260715085629 → 0.1.0

package/README.md

@@ -5,23 +5,20 @@ Hypequery artifacts.
 
 ## Current status
 
-This package now contains the proposed version 1 tagged ClickHouse value codec.
-The API remains pre-stable while the language-neutral specification and
-conformance fixtures are reviewed. It does not yet define an executable
-deployment bundle or a stable Cloud protocol.
+This package is an intentionally empty public scaffold. It does not yet define
+a stable protocol or an executable deployment bundle. Runtime exports will be
+added incrementally after their language-neutral specifications and conformance
+fixtures are accepted.
 
 The normative source is
 [`specs/security-protocol`](../../specs/security-protocol/README.md).
 
-## Scope
+## Intended scope
 
-The package contains deterministic, framework-independent implementations of
-accepted protocol rules. The current implementation provides strict tagged
-value validation, RFC 8785 canonical encoding, duplicate-aware decoding, a raw
-SHA-256 conformance digest, draft portable logical identifiers, and a proposed
-closed dataset expression/query AST. Artifact envelopes and compatibility
-checks will follow in separate changes. A closed portable query-schema tree
-provides the next layer for named-query input and output contracts.
+The package will contain deterministic, framework-independent implementations
+of accepted protocol rules, including strict validation, canonical encoding,
+digest calculation, identifiers, portable AST structures, artifact envelopes,
+and compatibility checks.
 
 It will not connect to ClickHouse, execute queries, load project source, access
 credentials or the environment, perform network or filesystem I/O, implement
@@ -37,33 +34,6 @@ Only the root package export is public. Deep imports from `src` or `dist` are
 unsupported. Package SemVer and protocol/artifact versions are separate; an
 installed npm version never determines an artifact's identity.
 
-The proposed tagged-value surface exports:
-
-- `validateCanonicalValue`
-- `encodeCanonicalValue` and `encodeCanonicalValueToString`
-- `decodeCanonicalValue`
-- `hashCanonicalValue`
-- `ProtocolValueError` and stable error-code types
-- tagged-value, option, and limit types
-
-The raw conformance digest is not a deployment identity or shared cache key.
-Those domains require separate, versioned, domain-separated contracts.
-
-The proposed identifier surface exports strict parse, guard, split, and join
-helpers for simple and dot-qualified logical identifiers. Identifiers are
-ASCII, case-sensitive, preserved exactly, and are not SQL identifiers.
-
-The proposed expression surface exports strict validators and immutable types
-for derived formulas, comparisons, filtered aggregations, all current dataset
-aggregations, and dataset/metric query envelopes. It intentionally excludes raw
-SQL and tenant identity; consumers validate names and policy against a dataset
-contract before execution.
-
-The proposed schema surface exports strict types and validation for portable
-query input/output schemas. It covers the current declarative Serve/Zod schema
-features without depending on Zod or embedding executable transforms and
-refinements.
-
 ## Runtime compatibility
 
 This package is ESM-only. Consumers must load it with `import`; CommonJS

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export { DEFAULT_CANONICAL_VALUE_LIMITS, ProtocolValueError, decodeCanonicalValue, encodeCanonicalValue, encodeCanonicalValueToString, hashCanonicalValue, validateCanonicalValue, } from './values/index.js';
-export type { ArrayTaggedValue, BytesTaggedValue, CanonicalValue, CanonicalValueLimits, CanonicalValueOptions, DateTaggedValue, DatetimeTaggedValue, DecimalTaggedValue, EnumTaggedValue, IntegerTaggedValue, MapTaggedValue, ProtocolValueErrorCode, TaggedValue, TupleTaggedValue, UuidTaggedValue, } from './values/index.js';
-export { PROTOCOL_IDENTIFIER_LIMITS, ProtocolIdentifierError, isProtocolIdentifier, isProtocolQualifiedIdentifier, joinProtocolQualifiedIdentifier, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, splitProtocolQualifiedIdentifier, } from './identifiers/index.js';
-export { DEFAULT_PROTOCOL_EXPRESSION_LIMITS, ProtocolExpressionError, validateProtocolExpression, validateProtocolSemanticQuery, } from './expressions/index.js';
-export { DEFAULT_PROTOCOL_SCHEMA_LIMITS, ProtocolSchemaError, validateProtocolSchema, } from './schemas/index.js';
-export type { ProtocolSchema, ProtocolSchemaErrorCode, ProtocolSchemaLimits, ProtocolSchemaOptions, } from './schemas/index.js';
-export type { ProtocolAggregation, ProtocolBinaryOperator, ProtocolComparisonOperator, ProtocolDatasetQuery, ProtocolExpression, ProtocolExpressionErrorCode, ProtocolExpressionLimits, ProtocolExpressionOptions, ProtocolFunctionName, ProtocolMetricQuery, ProtocolOrderBy, ProtocolSemanticQuery, ProtocolTimeGrain, } from './expressions/index.js';
-export type { ProtocolIdentifier, ProtocolIdentifierErrorCode, ProtocolQualifiedIdentifier, } from './identifiers/index.js';
+/**
+ * Public TypeScript reference implementation for the Hypequery protocol.
+ *
+ * The scaffold intentionally exports no runtime contract. Each future export
+ * must implement an accepted specification and ship with normative fixtures.
+ * See `specs/security-protocol/` in the repository.
+ */
+export {};
 //# 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":"AAAA,OAAO,EACL,8BAA8B,EAC9B,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,4BAA4B,EAC5B,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,kBAAkB,EAClB,cAAc,EACd,sBAAsB,EACtB,WAAW,EACX,gBAAgB,EAChB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,EACvB,oBAAoB,EACpB,6BAA6B,EAC7B,+BAA+B,EAC/B,uBAAuB,EACvB,gCAAgC,EAChC,gCAAgC,GACjC,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,kCAAkC,EAClC,uBAAuB,EACvB,0BAA0B,EAC1B,6BAA6B,GAC9B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,8BAA8B,EAC9B,mBAAmB,EACnB,sBAAsB,GACvB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,cAAc,EACd,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,EAC1B,oBAAoB,EACpB,kBAAkB,EAClB,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,kBAAkB,EAClB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,CAAC"}

package/dist/index.js

@@ -1,4 +1 @@
-export { DEFAULT_CANONICAL_VALUE_LIMITS, ProtocolValueError, decodeCanonicalValue, encodeCanonicalValue, encodeCanonicalValueToString, hashCanonicalValue, validateCanonicalValue, } from './values/index.js';
-export { PROTOCOL_IDENTIFIER_LIMITS, ProtocolIdentifierError, isProtocolIdentifier, isProtocolQualifiedIdentifier, joinProtocolQualifiedIdentifier, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, splitProtocolQualifiedIdentifier, } from './identifiers/index.js';
-export { DEFAULT_PROTOCOL_EXPRESSION_LIMITS, ProtocolExpressionError, validateProtocolExpression, validateProtocolSemanticQuery, } from './expressions/index.js';
-export { DEFAULT_PROTOCOL_SCHEMA_LIMITS, ProtocolSchemaError, validateProtocolSchema, } from './schemas/index.js';
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypequery/protocol",
-  "version": "0.0.0-canary-20260715085629",
+  "version": "0.1.0",
   "description": "Public contracts and TypeScript reference implementation for portable Hypequery artifacts",
   "license": "Apache-2.0",
   "type": "module",
@@ -17,9 +17,6 @@
     "dist",
     "README.md"
   ],
-  "dependencies": {
-    "@noble/hashes": "^1.8.0"
-  },
   "devDependencies": {
     "typescript": "^5.7.3",
     "vitest": "^3.2.6"

package/dist/expressions/errors.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/expressions/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAC;AAE9D,qBAAa,uBAAwB,SAAQ,SAAS;IACpD,QAAQ,CAAC,IAAI,EAAE,2BAA2B,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,2BAA2B,EAAE,IAAI,SAAM;CAM1D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,2BAA2B,EAAE,IAAI,SAAM,GAAG,KAAK,CAEpF"}

package/dist/expressions/errors.js

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

package/dist/expressions/index.d.ts

@@ -1,5 +0,0 @@
-export { ProtocolExpressionError } from './errors.js';
-export { DEFAULT_PROTOCOL_EXPRESSION_LIMITS } from './limits.js';
-export { validateProtocolExpression, validateProtocolSemanticQuery } from './validate.js';
-export type { ProtocolAggregation, ProtocolBinaryOperator, ProtocolComparisonOperator, ProtocolDatasetQuery, ProtocolExpression, ProtocolExpressionErrorCode, ProtocolExpressionLimits, ProtocolExpressionOptions, ProtocolFunctionName, ProtocolMetricQuery, ProtocolOrderBy, ProtocolSemanticQuery, ProtocolTimeGrain, } from './types.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/expressions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,EAAE,kCAAkC,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,0BAA0B,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC;AAC1F,YAAY,EACV,mBAAmB,EACnB,sBAAsB,EACtB,0BAA0B,EAC1B,oBAAoB,EACpB,kBAAkB,EAClB,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/expressions/index.js

@@ -1,3 +0,0 @@
-export { ProtocolExpressionError } from './errors.js';
-export { DEFAULT_PROTOCOL_EXPRESSION_LIMITS } from './limits.js';
-export { validateProtocolExpression, validateProtocolSemanticQuery } from './validate.js';

package/dist/expressions/limits.d.ts

@@ -1,4 +0,0 @@
-import type { ProtocolExpressionLimits, ProtocolExpressionOptions } from './types.js';
-export declare const DEFAULT_PROTOCOL_EXPRESSION_LIMITS: Readonly<ProtocolExpressionLimits>;
-export declare function resolveExpressionLimits(options?: ProtocolExpressionOptions): Readonly<ProtocolExpressionLimits>;
-//# sourceMappingURL=limits.d.ts.map

package/dist/expressions/limits.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../../src/expressions/limits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAEtF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,wBAAwB,CAIhF,CAAC;AAEH,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,yBAA8B,GACtC,QAAQ,CAAC,wBAAwB,CAAC,CAWpC"}

package/dist/expressions/limits.js

@@ -1,17 +0,0 @@
-export const DEFAULT_PROTOCOL_EXPRESSION_LIMITS = Object.freeze({
-    maxDepth: 16,
-    maxNodes: 1_000,
-    maxCollectionItems: 100,
-});
-export function resolveExpressionLimits(options = {}) {
-    const limits = { ...DEFAULT_PROTOCOL_EXPRESSION_LIMITS };
-    for (const key of Object.keys(options.limits ?? {})) {
-        const value = options.limits?.[key];
-        if (!Number.isSafeInteger(value) || value < 1
-            || value > DEFAULT_PROTOCOL_EXPRESSION_LIMITS[key]) {
-            throw new RangeError(`${key} must be a positive integer no greater than the protocol v1 maximum`);
-        }
-        limits[key] = value;
-    }
-    return Object.freeze(limits);
-}

package/dist/expressions/types.d.ts

@@ -1,77 +0,0 @@
-import type { ProtocolIdentifier, ProtocolQualifiedIdentifier } from '../identifiers/index.js';
-import type { CanonicalValue } from '../values/index.js';
-export type ProtocolBinaryOperator = 'add' | 'subtract' | 'multiply' | 'divide';
-export type ProtocolFunctionName = 'nullIfZero' | 'coalesce' | 'round' | 'floor' | 'ceil';
-export type ProtocolComparisonOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'notIn' | 'between' | 'like';
-export type ProtocolAggregation = 'sum' | 'count' | 'countDistinct' | 'avg' | 'min' | 'max' | 'argMax' | 'argMin' | 'percentile' | 'stddev' | 'variance';
-export type ProtocolExpression = {
-    readonly kind: 'reference';
-    readonly name: ProtocolQualifiedIdentifier;
-} | {
-    readonly kind: 'literal';
-    readonly value: CanonicalValue;
-} | {
-    readonly kind: 'binary';
-    readonly operator: ProtocolBinaryOperator;
-    readonly left: ProtocolExpression;
-    readonly right: ProtocolExpression;
-} | {
-    readonly kind: 'call';
-    readonly function: ProtocolFunctionName;
-    readonly args: readonly ProtocolExpression[];
-} | {
-    readonly kind: 'comparison';
-    readonly operator: ProtocolComparisonOperator;
-    readonly left: ProtocolExpression;
-    readonly right: ProtocolExpression;
-} | {
-    readonly kind: 'logical';
-    readonly operator: 'and' | 'or';
-    readonly operands: readonly ProtocolExpression[];
-} | {
-    readonly kind: 'logical';
-    readonly operator: 'not';
-    readonly operand: ProtocolExpression;
-} | {
-    readonly kind: 'aggregate';
-    readonly aggregation: ProtocolAggregation;
-    readonly field: ProtocolQualifiedIdentifier;
-    readonly argField?: ProtocolQualifiedIdentifier;
-    readonly level?: number;
-    readonly filters?: readonly ProtocolExpression[];
-};
-export type ProtocolTimeGrain = 'day' | 'week' | 'month' | 'quarter' | 'year';
-export interface ProtocolOrderBy {
-    readonly field: ProtocolQualifiedIdentifier;
-    readonly direction: 'asc' | 'desc';
-}
-interface ProtocolQueryCommon {
-    readonly dataset: ProtocolIdentifier;
-    readonly dimensions?: readonly ProtocolQualifiedIdentifier[];
-    readonly filters?: readonly ProtocolExpression[];
-    readonly orderBy?: readonly ProtocolOrderBy[];
-    readonly limit?: number;
-    readonly offset?: number;
-    readonly by?: ProtocolTimeGrain;
-    readonly includeMeta?: boolean;
-}
-export interface ProtocolDatasetQuery extends ProtocolQueryCommon {
-    readonly kind: 'dataset';
-    readonly measures?: readonly ProtocolIdentifier[];
-}
-export interface ProtocolMetricQuery extends ProtocolQueryCommon {
-    readonly kind: 'metric';
-    readonly metric: ProtocolIdentifier;
-}
-export type ProtocolSemanticQuery = ProtocolDatasetQuery | ProtocolMetricQuery;
-export interface ProtocolExpressionLimits {
-    readonly maxDepth: number;
-    readonly maxNodes: number;
-    readonly maxCollectionItems: number;
-}
-export interface ProtocolExpressionOptions {
-    readonly limits?: Partial<ProtocolExpressionLimits>;
-}
-export type ProtocolExpressionErrorCode = 'HQ_EXPRESSION_TYPE' | 'HQ_EXPRESSION_UNKNOWN_FIELD' | 'HQ_EXPRESSION_UNKNOWN_KIND' | 'HQ_EXPRESSION_INVALID_IDENTIFIER' | 'HQ_EXPRESSION_INVALID_VALUE' | 'HQ_EXPRESSION_INVALID_OPERATOR' | 'HQ_EXPRESSION_INVALID_ARITY' | 'HQ_EXPRESSION_INVALID_AGGREGATION' | 'HQ_EXPRESSION_INVALID_QUERY' | 'HQ_EXPRESSION_TOO_DEEP' | 'HQ_EXPRESSION_TOO_MANY_NODES' | 'HQ_EXPRESSION_TOO_MANY_ITEMS' | 'HQ_EXPRESSION_UNSAFE_OBJECT';
-export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/expressions/types.d.ts.map

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

package/dist/expressions/types.js

@@ -1 +0,0 @@
-export {};

package/dist/expressions/validate.d.ts

@@ -1,4 +0,0 @@
-import type { ProtocolExpression, ProtocolExpressionOptions, ProtocolSemanticQuery } from './types.js';
-export declare function validateProtocolExpression(input: unknown, options?: ProtocolExpressionOptions): ProtocolExpression;
-export declare function validateProtocolSemanticQuery(input: unknown, options?: ProtocolExpressionOptions): ProtocolSemanticQuery;
-//# sourceMappingURL=validate.d.ts.map

package/dist/expressions/validate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/expressions/validate.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAEV,kBAAkB,EAElB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AA4PpB,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,yBAA8B,GACtC,kBAAkB,CAEpB;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,yBAA8B,GACtC,qBAAqB,CAiDvB"}

package/dist/expressions/validate.js

@@ -1,338 +0,0 @@
-import { ProtocolIdentifierError, parseProtocolIdentifier, parseProtocolQualifiedIdentifier, } from '../identifiers/index.js';
-import { ProtocolValueError, validateCanonicalValue } from '../values/index.js';
-import { expressionError } from './errors.js';
-import { resolveExpressionLimits } from './limits.js';
-const BINARY = new Set(['add', 'subtract', 'multiply', 'divide']);
-const COMPARISONS = new Set(['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'between', 'like']);
-const AGGREGATIONS = new Set([
-    'sum', 'count', 'countDistinct', 'avg', 'min', 'max',
-    'argMax', 'argMin', 'percentile', 'stddev', 'variance',
-]);
-const GRAINS = new Set(['day', 'week', 'month', 'quarter', 'year']);
-const CALL_ARITY = Object.freeze({
-    nullIfZero: [1, 1],
-    coalesce: [2, 2],
-    round: [1, 2],
-    floor: [1, 1],
-    ceil: [1, 1],
-});
-function requireRecord(input, path) {
-    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
-        expressionError('HQ_EXPRESSION_TYPE', path);
-    }
-    const prototype = Object.getPrototypeOf(input);
-    if (prototype !== Object.prototype && prototype !== null) {
-        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
-    }
-    const descriptors = Object.getOwnPropertyDescriptors(input);
-    if (Object.getOwnPropertySymbols(input).length > 0) {
-        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
-    }
-    for (const descriptor of Object.values(descriptors)) {
-        if (!descriptor.enumerable || !('value' in descriptor)) {
-            expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
-        }
-    }
-    return input;
-}
-function exactFields(value, required, optional, path) {
-    const allowed = new Set([...required, ...optional]);
-    for (const key of Object.keys(value)) {
-        if (!allowed.has(key))
-            expressionError('HQ_EXPRESSION_UNKNOWN_FIELD', `${path}.${key}`);
-    }
-    for (const key of required) {
-        if (!Object.hasOwn(value, key))
-            expressionError('HQ_EXPRESSION_TYPE', `${path}.${key}`);
-    }
-}
-function stringValue(value, path) {
-    if (typeof value !== 'string')
-        expressionError('HQ_EXPRESSION_TYPE', path);
-    return value;
-}
-function identifier(value, path, qualified = true) {
-    try {
-        return qualified ? parseProtocolQualifiedIdentifier(value) : parseProtocolIdentifier(value);
-    }
-    catch (error) {
-        if (error instanceof ProtocolIdentifierError) {
-            expressionError('HQ_EXPRESSION_INVALID_IDENTIFIER', path);
-        }
-        throw error;
-    }
-}
-function enter(value, depth, state, path) {
-    if (depth > state.limits.maxDepth)
-        expressionError('HQ_EXPRESSION_TOO_DEEP', path);
-    state.nodes += 1;
-    if (state.nodes > state.limits.maxNodes)
-        expressionError('HQ_EXPRESSION_TOO_MANY_NODES', path);
-    if (state.active.has(value))
-        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
-    state.active.add(value);
-}
-function arrayValue(value, path, state) {
-    if (!Array.isArray(value))
-        expressionError('HQ_EXPRESSION_TYPE', path);
-    if (Object.getPrototypeOf(value) !== Array.prototype || Object.getOwnPropertySymbols(value).length > 0) {
-        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
-    }
-    if (value.length > state.limits.maxCollectionItems)
-        expressionError('HQ_EXPRESSION_TOO_MANY_ITEMS', path);
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-    for (let index = 0; index < value.length; index += 1) {
-        const descriptor = descriptors[String(index)];
-        if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) {
-            expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', `${path}[${index}]`);
-        }
-    }
-    if (Object.keys(value).length !== value.length) {
-        expressionError('HQ_EXPRESSION_UNSAFE_OBJECT', path);
-    }
-    return value;
-}
-function freezeRecord(entries) {
-    return Object.freeze(Object.assign(Object.create(null), entries));
-}
-function validateExpression(input, path, depth, state) {
-    const value = requireRecord(input, path);
-    enter(value, depth, state, path);
-    try {
-        const kind = stringValue(value.kind, `${path}.kind`);
-        switch (kind) {
-            case 'reference': {
-                exactFields(value, ['kind', 'name'], [], path);
-                return freezeRecord({ kind, name: identifier(value.name, `${path}.name`) });
-            }
-            case 'literal': {
-                exactFields(value, ['kind', 'value'], [], path);
-                try {
-                    return freezeRecord({ kind, value: validateCanonicalValue(value.value) });
-                }
-                catch (error) {
-                    if (error instanceof ProtocolValueError)
-                        expressionError('HQ_EXPRESSION_INVALID_VALUE', `${path}.value`);
-                    throw error;
-                }
-            }
-            case 'binary': {
-                exactFields(value, ['kind', 'operator', 'left', 'right'], [], path);
-                const operator = stringValue(value.operator, `${path}.operator`);
-                if (!BINARY.has(operator))
-                    expressionError('HQ_EXPRESSION_INVALID_OPERATOR', `${path}.operator`);
-                return freezeRecord({
-                    kind,
-                    operator,
-                    left: validateExpression(value.left, `${path}.left`, depth + 1, state),
-                    right: validateExpression(value.right, `${path}.right`, depth + 1, state),
-                });
-            }
-            case 'call': {
-                exactFields(value, ['kind', 'function', 'args'], [], path);
-                const fn = stringValue(value.function, `${path}.function`);
-                const arity = CALL_ARITY[fn];
-                if (!arity)
-                    expressionError('HQ_EXPRESSION_INVALID_OPERATOR', `${path}.function`);
-                const args = arrayValue(value.args, `${path}.args`, state);
-                if (args.length < arity[0] || args.length > arity[1]) {
-                    expressionError('HQ_EXPRESSION_INVALID_ARITY', `${path}.args`);
-                }
-                return freezeRecord({
-                    kind,
-                    function: fn,
-                    args: Object.freeze(args.map((arg, index) => validateExpression(arg, `${path}.args[${index}]`, depth + 1, state))),
-                });
-            }
-            case 'comparison': {
-                exactFields(value, ['kind', 'operator', 'left', 'right'], [], path);
-                const operator = stringValue(value.operator, `${path}.operator`);
-                if (!COMPARISONS.has(operator))
-                    expressionError('HQ_EXPRESSION_INVALID_OPERATOR', `${path}.operator`);
-                const left = validateExpression(value.left, `${path}.left`, depth + 1, state);
-                const right = validateExpression(value.right, `${path}.right`, depth + 1, state);
-                validateComparisonOperands(operator, right, `${path}.right`);
-                return freezeRecord({
-                    kind,
-                    operator,
-                    left,
-                    right,
-                });
-            }
-            case 'logical': {
-                exactFields(value, ['kind', 'operator'], ['operand', 'operands'], path);
-                const operator = stringValue(value.operator, `${path}.operator`);
-                if (operator === 'not') {
-                    if (!Object.hasOwn(value, 'operand') || Object.hasOwn(value, 'operands')) {
-                        expressionError('HQ_EXPRESSION_INVALID_ARITY', path);
-                    }
-                    return freezeRecord({ kind, operator, operand: validateExpression(value.operand, `${path}.operand`, depth + 1, state) });
-                }
-                if (operator !== 'and' && operator !== 'or')
-                    expressionError('HQ_EXPRESSION_INVALID_OPERATOR', `${path}.operator`);
-                if (!Object.hasOwn(value, 'operands') || Object.hasOwn(value, 'operand')) {
-                    expressionError('HQ_EXPRESSION_INVALID_ARITY', path);
-                }
-                const operands = arrayValue(value.operands, `${path}.operands`, state);
-                if (operands.length < 2)
-                    expressionError('HQ_EXPRESSION_INVALID_ARITY', `${path}.operands`);
-                return freezeRecord({
-                    kind,
-                    operator,
-                    operands: Object.freeze(operands.map((operand, index) => validateExpression(operand, `${path}.operands[${index}]`, depth + 1, state))),
-                });
-            }
-            case 'aggregate':
-                return validateAggregate(value, path, depth, state);
-            default:
-                expressionError('HQ_EXPRESSION_UNKNOWN_KIND', `${path}.kind`);
-        }
-    }
-    finally {
-        state.active.delete(value);
-    }
-}
-function validateComparisonOperands(operator, right, path) {
-    if (operator === 'like') {
-        if (right.kind !== 'literal' || typeof right.value !== 'string') {
-            expressionError('HQ_EXPRESSION_INVALID_VALUE', path);
-        }
-        return;
-    }
-    if (operator !== 'in' && operator !== 'notIn' && operator !== 'between')
-        return;
-    if (right.kind !== 'literal' || typeof right.value !== 'object' || right.value === null
-        || !('$hypequery' in right.value)) {
-        expressionError('HQ_EXPRESSION_INVALID_VALUE', path);
-    }
-    const tag = right.value.$hypequery;
-    const expectedType = operator === 'between' ? 'tuple' : 'array';
-    if (tag.type !== expectedType || !('values' in tag)) {
-        expressionError('HQ_EXPRESSION_INVALID_VALUE', path);
-    }
-    const requiredLength = operator === 'between' ? 2 : undefined;
-    if (tag.values.length === 0 || (requiredLength !== undefined && tag.values.length !== requiredLength)) {
-        expressionError('HQ_EXPRESSION_INVALID_ARITY', path);
-    }
-}
-function validateAggregate(value, path, depth, state) {
-    exactFields(value, ['kind', 'aggregation', 'field'], ['argField', 'level', 'filters'], path);
-    const aggregation = stringValue(value.aggregation, `${path}.aggregation`);
-    if (!AGGREGATIONS.has(aggregation))
-        expressionError('HQ_EXPRESSION_INVALID_AGGREGATION', `${path}.aggregation`);
-    const isArg = aggregation === 'argMax' || aggregation === 'argMin';
-    const isPercentile = aggregation === 'percentile';
-    if (isArg !== Object.hasOwn(value, 'argField') || isPercentile !== Object.hasOwn(value, 'level')) {
-        expressionError('HQ_EXPRESSION_INVALID_AGGREGATION', path);
-    }
-    if (isArg && Object.hasOwn(value, 'filters'))
-        expressionError('HQ_EXPRESSION_INVALID_AGGREGATION', `${path}.filters`);
-    const level = value.level;
-    if (isPercentile && (typeof level !== 'number' || !Number.isFinite(level) || level < 0 || level > 1)) {
-        expressionError('HQ_EXPRESSION_INVALID_AGGREGATION', `${path}.level`);
-    }
-    const filters = value.filters === undefined ? undefined : arrayValue(value.filters, `${path}.filters`, state);
-    return freezeRecord({
-        kind: 'aggregate',
-        aggregation,
-        field: identifier(value.field, `${path}.field`),
-        ...(isArg ? { argField: identifier(value.argField, `${path}.argField`) } : {}),
-        ...(isPercentile ? { level } : {}),
-        ...(filters ? {
-            filters: Object.freeze(filters.map((filter, index) => validatePredicate(filter, `${path}.filters[${index}]`, depth + 1, state, 'HQ_EXPRESSION_INVALID_AGGREGATION'))),
-        } : {}),
-    });
-}
-function newState(options) {
-    return { limits: resolveExpressionLimits(options), active: new WeakSet(), nodes: 0 };
-}
-export function validateProtocolExpression(input, options = {}) {
-    return validateExpression(input, '$', 1, newState(options));
-}
-export function validateProtocolSemanticQuery(input, options = {}) {
-    const state = newState(options);
-    const value = requireRecord(input, '$');
-    enter(value, 1, state, '$');
-    try {
-        const kind = stringValue(value.kind, '$.kind');
-        const metric = kind === 'metric';
-        if (!metric && kind !== 'dataset')
-            expressionError('HQ_EXPRESSION_INVALID_QUERY', '$.kind');
-        exactFields(value, metric ? ['kind', 'dataset', 'metric'] : ['kind', 'dataset'], metric
-            ? ['dimensions', 'filters', 'orderBy', 'limit', 'offset', 'by', 'includeMeta']
-            : ['dimensions', 'measures', 'filters', 'orderBy', 'limit', 'offset', 'by', 'includeMeta'], '$');
-        const result = {
-            kind,
-            dataset: identifier(value.dataset, '$.dataset', false),
-            ...(metric ? { metric: identifier(value.metric, '$.metric', false) } : {}),
-        };
-        copyIdentifierArray(value, result, 'dimensions', true, state);
-        if (!metric)
-            copyIdentifierArray(value, result, 'measures', false, state);
-        if (value.filters !== undefined) {
-            const filters = arrayValue(value.filters, '$.filters', state);
-            result.filters = Object.freeze(filters.map((filter, index) => validatePredicate(filter, `$.filters[${index}]`, 1, state, 'HQ_EXPRESSION_INVALID_QUERY')));
-        }
-        if (value.orderBy !== undefined)
-            result.orderBy = validateOrderBy(value.orderBy, state);
-        copyInteger(value, result, 'limit', 0);
-        copyInteger(value, result, 'offset', 0);
-        if (value.by !== undefined) {
-            const grain = stringValue(value.by, '$.by');
-            if (!GRAINS.has(grain))
-                expressionError('HQ_EXPRESSION_INVALID_QUERY', '$.by');
-            result.by = grain;
-        }
-        if (value.includeMeta !== undefined) {
-            if (typeof value.includeMeta !== 'boolean')
-                expressionError('HQ_EXPRESSION_INVALID_QUERY', '$.includeMeta');
-            result.includeMeta = value.includeMeta;
-        }
-        return freezeRecord(result);
-    }
-    finally {
-        state.active.delete(value);
-    }
-}
-function validatePredicate(input, path, depth, state, errorCode) {
-    const expression = validateExpression(input, path, depth, state);
-    if (!isPredicate(expression))
-        expressionError(errorCode, path);
-    return expression;
-}
-function isPredicate(expression) {
-    if (expression.kind === 'comparison')
-        return true;
-    if (expression.kind !== 'logical')
-        return false;
-    return expression.operator === 'not'
-        ? isPredicate(expression.operand)
-        : expression.operands.every(isPredicate);
-}
-function copyIdentifierArray(source, target, key, qualified, state) {
-    if (source[key] === undefined)
-        return;
-    const values = arrayValue(source[key], `$.${key}`, state);
-    target[key] = Object.freeze(values.map((item, index) => identifier(item, `$.${key}[${index}]`, qualified)));
-}
-function copyInteger(source, target, key, minimum) {
-    if (source[key] === undefined)
-        return;
-    const value = source[key];
-    if (!Number.isSafeInteger(value) || value < minimum) {
-        expressionError('HQ_EXPRESSION_INVALID_QUERY', `$.${key}`);
-    }
-    target[key] = value;
-}
-function validateOrderBy(input, state) {
-    const values = arrayValue(input, '$.orderBy', state);
-    return Object.freeze(values.map((item, index) => {
-        const path = `$.orderBy[${index}]`;
-        const value = requireRecord(item, path);
-        exactFields(value, ['field', 'direction'], [], path);
-        const direction = stringValue(value.direction, `${path}.direction`);
-        if (direction !== 'asc' && direction !== 'desc')
-            expressionError('HQ_EXPRESSION_INVALID_QUERY', `${path}.direction`);
-        return freezeRecord({ field: identifier(value.field, `${path}.field`), direction });
-    }));
-}

package/dist/identifiers/identifiers.d.ts

@@ -1,14 +0,0 @@
-import { type ProtocolIdentifier, type ProtocolIdentifierErrorCode, type ProtocolQualifiedIdentifier } from './types.js';
-export declare class ProtocolIdentifierError extends TypeError {
-    readonly code: ProtocolIdentifierErrorCode;
-    constructor(code: ProtocolIdentifierErrorCode);
-}
-/** Parses one portable, case-sensitive logical identifier segment. */
-export declare function parseProtocolIdentifier(input: unknown): ProtocolIdentifier;
-/** Parses a dot-qualified portable identifier without normalizing it. */
-export declare function parseProtocolQualifiedIdentifier(input: unknown): ProtocolQualifiedIdentifier;
-export declare function splitProtocolQualifiedIdentifier(input: ProtocolQualifiedIdentifier): readonly ProtocolIdentifier[];
-export declare function joinProtocolQualifiedIdentifier(segments: readonly unknown[]): ProtocolQualifiedIdentifier;
-export declare function isProtocolIdentifier(input: unknown): input is ProtocolIdentifier;
-export declare function isProtocolQualifiedIdentifier(input: unknown): input is ProtocolQualifiedIdentifier;
-//# sourceMappingURL=identifiers.d.ts.map