@spotto/semantic-query 1.0.70-alpha.34 → 1.0.70-alpha.35

package/dist/resolve-name.js

@@ -1,91 +1,91 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveName = void 0;
-/**
- * Resolve a NAME to the ids it means — the one place a human word becomes a
- * record reference.
- *
- * The ladder is exact → case-insensitive → unique partial, and it is
- * deliberately conservative at every rung:
- *
- *  - An EXACT match wins outright, even if partials also exist. "Bob" must not
- *    become ambiguous just because "Bobby" is also on staff.
- *  - Several records sharing one exact name resolve to ALL of them. Two people
- *    genuinely called "Sam Lee" is a data fact, not a question to ask; both are
- *    matched and the answer covers the name as asked.
- *  - A partial match is accepted ONLY when it is unique. "Bri" matching both
- *    "Brian" and "Brisbane Bob" is refused, with both named, because picking
- *    one would answer a different question and look exactly like an answer.
- *  - No match is refused with the nearest candidates offered.
- *
- * The failure modes are what make this safe to expose to a model. A regex
- * fallback — which is what the prototype did for assets — would match whatever
- * it happened to match, silently.
- */
-/**
- * How many candidates an ambiguity message names. Enough to disambiguate a
- * genuine near-miss, few enough that the error is not a directory listing.
- */
-const AMBIGUITY_EXAMPLES = 3;
-/** Up to three nearest candidates by simple containment, for a suggestion. */
-function nearest(catalogue, want) {
-    const needle = want.trim().toLowerCase();
-    if (!needle)
-        return undefined;
-    const hits = catalogue
-        .filter((r) => {
-        const n = r.name.toLowerCase();
-        return n.includes(needle.slice(0, 3)) || needle.includes(n.slice(0, 3));
-    })
-        .slice(0, 3)
-        .map((r) => { var _a; return (_a = r.label) !== null && _a !== void 0 ? _a : r.name; });
-    return hits.length ? `Did you mean: ${hits.join(', ')}?` : undefined;
-}
-function resolveName(catalogue, rawName, opts) {
-    const want = typeof rawName === 'string' ? rawName.trim() : '';
-    if (!want) {
-        return {
-            ids: [],
-            issue: {
-                code: 'BAD_SHAPE',
-                path: opts.path,
-                message: `${opts.noun} needs a name`,
-            },
-        };
-    }
-    const all = catalogue !== null && catalogue !== void 0 ? catalogue : [];
-    const lower = want.toLowerCase();
-    const exact = all.filter((r) => r.name.toLowerCase() === lower);
-    const partial = all.filter((r) => r.name.toLowerCase().includes(lower));
-    // Exact wins outright — a longer name that merely CONTAINS this one must not
-    // make an exact match ambiguous.
-    const hit = exact.length ? exact : partial;
-    if (!hit.length) {
-        return {
-            ids: [],
-            issue: Object.assign({ code: 'UNKNOWN_NAME', path: opts.path, message: `No ${opts.noun} called '${want}' in this organisation` }, (nearest(all, want) ? { suggestion: nearest(all, want) } : {})),
-        };
-    }
-    if (!exact.length && partial.length > 1) {
-        // NAMED, NOT ENUMERATED. Listing every match turns this message into a
-        // directory: the catalogue is org-scoped but not user-group scoped, and
-        // these endpoints are gated on `assets:view` rather than `users:view` — so
-        // an unbounded list let a confined field worker recover the whole staff
-        // roster one letter at a time. A handful of examples is what makes the
-        // error actionable; the rest is only useful to someone fishing.
-        const shown = partial.slice(0, AMBIGUITY_EXAMPLES).map((r) => { var _a; return (_a = r.label) !== null && _a !== void 0 ? _a : r.name; });
-        const rest = partial.length - shown.length;
-        return {
-            ids: [],
-            issue: {
-                code: 'AMBIGUOUS_NAME',
-                path: opts.path,
-                message: `'${want}' matches ${partial.length} ${opts.noun}s ` +
-                    `(${shown.join(', ')}${rest > 0 ? `, and ${rest} more` : ''}) — be more specific`,
-            },
-        };
-    }
-    return { ids: [...new Set(hit.map((r) => r.id))] };
-}
-exports.resolveName = resolveName;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveName = void 0;
+/**
+ * Resolve a NAME to the ids it means — the one place a human word becomes a
+ * record reference.
+ *
+ * The ladder is exact → case-insensitive → unique partial, and it is
+ * deliberately conservative at every rung:
+ *
+ *  - An EXACT match wins outright, even if partials also exist. "Bob" must not
+ *    become ambiguous just because "Bobby" is also on staff.
+ *  - Several records sharing one exact name resolve to ALL of them. Two people
+ *    genuinely called "Sam Lee" is a data fact, not a question to ask; both are
+ *    matched and the answer covers the name as asked.
+ *  - A partial match is accepted ONLY when it is unique. "Bri" matching both
+ *    "Brian" and "Brisbane Bob" is refused, with both named, because picking
+ *    one would answer a different question and look exactly like an answer.
+ *  - No match is refused with the nearest candidates offered.
+ *
+ * The failure modes are what make this safe to expose to a model. A regex
+ * fallback — which is what the prototype did for assets — would match whatever
+ * it happened to match, silently.
+ */
+/**
+ * How many candidates an ambiguity message names. Enough to disambiguate a
+ * genuine near-miss, few enough that the error is not a directory listing.
+ */
+const AMBIGUITY_EXAMPLES = 3;
+/** Up to three nearest candidates by simple containment, for a suggestion. */
+function nearest(catalogue, want) {
+    const needle = want.trim().toLowerCase();
+    if (!needle)
+        return undefined;
+    const hits = catalogue
+        .filter((r) => {
+        const n = r.name.toLowerCase();
+        return n.includes(needle.slice(0, 3)) || needle.includes(n.slice(0, 3));
+    })
+        .slice(0, 3)
+        .map((r) => { var _a; return (_a = r.label) !== null && _a !== void 0 ? _a : r.name; });
+    return hits.length ? `Did you mean: ${hits.join(', ')}?` : undefined;
+}
+function resolveName(catalogue, rawName, opts) {
+    const want = typeof rawName === 'string' ? rawName.trim() : '';
+    if (!want) {
+        return {
+            ids: [],
+            issue: {
+                code: 'BAD_SHAPE',
+                path: opts.path,
+                message: `${opts.noun} needs a name`,
+            },
+        };
+    }
+    const all = catalogue !== null && catalogue !== void 0 ? catalogue : [];
+    const lower = want.toLowerCase();
+    const exact = all.filter((r) => r.name.toLowerCase() === lower);
+    const partial = all.filter((r) => r.name.toLowerCase().includes(lower));
+    // Exact wins outright — a longer name that merely CONTAINS this one must not
+    // make an exact match ambiguous.
+    const hit = exact.length ? exact : partial;
+    if (!hit.length) {
+        return {
+            ids: [],
+            issue: Object.assign({ code: 'UNKNOWN_NAME', path: opts.path, message: `No ${opts.noun} called '${want}' in this organisation` }, (nearest(all, want) ? { suggestion: nearest(all, want) } : {})),
+        };
+    }
+    if (!exact.length && partial.length > 1) {
+        // NAMED, NOT ENUMERATED. Listing every match turns this message into a
+        // directory: the catalogue is org-scoped but not user-group scoped, and
+        // these endpoints are gated on `assets:view` rather than `users:view` — so
+        // an unbounded list let a confined field worker recover the whole staff
+        // roster one letter at a time. A handful of examples is what makes the
+        // error actionable; the rest is only useful to someone fishing.
+        const shown = partial.slice(0, AMBIGUITY_EXAMPLES).map((r) => { var _a; return (_a = r.label) !== null && _a !== void 0 ? _a : r.name; });
+        const rest = partial.length - shown.length;
+        return {
+            ids: [],
+            issue: {
+                code: 'AMBIGUOUS_NAME',
+                path: opts.path,
+                message: `'${want}' matches ${partial.length} ${opts.noun}s ` +
+                    `(${shown.join(', ')}${rest > 0 ? `, and ${rest} more` : ''}) — be more specific`,
+            },
+        };
+    }
+    return { ids: [...new Set(hit.map((r) => r.id))] };
+}
+exports.resolveName = resolveName;
 //# sourceMappingURL=resolve-name.js.map

package/dist/suggest.d.ts

@@ -1,12 +1,12 @@
-/**
- * Nearest-candidate matching for "did you mean…" suggestions on validation
- * errors — an unknown field or dropdown value is rejected WITH the closest
- * real name, so an honest error is also an actionable one.
- *
- * Substring matching alone is not enough: the canonical case is
- * `SerialNo` → `SerialNumber`, and "serialno" is NOT a substring of
- * "serialnumber" (…n-o… vs …n-u…) nor within any sane edit-distance
- * tolerance (5 edits). The longest-shared-prefix pass is what makes that
- * documented case actually produce a suggestion.
- */
-export declare function nearest(candidates: string[], wanted: string): string | undefined;
+/**
+ * Nearest-candidate matching for "did you mean…" suggestions on validation
+ * errors — an unknown field or dropdown value is rejected WITH the closest
+ * real name, so an honest error is also an actionable one.
+ *
+ * Substring matching alone is not enough: the canonical case is
+ * `SerialNo` → `SerialNumber`, and "serialno" is NOT a substring of
+ * "serialnumber" (…n-o… vs …n-u…) nor within any sane edit-distance
+ * tolerance (5 edits). The longest-shared-prefix pass is what makes that
+ * documented case actually produce a suggestion.
+ */
+export declare function nearest(candidates: string[], wanted: string): string | undefined;

package/dist/suggest.js

@@ -1,70 +1,70 @@
-"use strict";
-/**
- * Nearest-candidate matching for "did you mean…" suggestions on validation
- * errors — an unknown field or dropdown value is rejected WITH the closest
- * real name, so an honest error is also an actionable one.
- *
- * Substring matching alone is not enough: the canonical case is
- * `SerialNo` → `SerialNumber`, and "serialno" is NOT a substring of
- * "serialnumber" (…n-o… vs …n-u…) nor within any sane edit-distance
- * tolerance (5 edits). The longest-shared-prefix pass is what makes that
- * documented case actually produce a suggestion.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nearest = void 0;
-function editDistance(a, b) {
-    const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
-    const cur = new Array(b.length + 1);
-    for (let i = 1; i <= a.length; i++) {
-        cur[0] = i;
-        for (let j = 1; j <= b.length; j++) {
-            cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-        }
-        prev.splice(0, prev.length, ...cur);
-    }
-    return prev[b.length];
-}
-function nearest(candidates, wanted) {
-    const w = wanted.toLowerCase().trim();
-    if (!w)
-        return undefined;
-    const lower = candidates.map((c) => c.toLowerCase());
-    const exact = lower.indexOf(w);
-    if (exact >= 0)
-        return candidates[exact];
-    for (let i = 0; i < lower.length; i++) {
-        if (lower[i].startsWith(w) || w.startsWith(lower[i]))
-            return candidates[i];
-    }
-    for (let i = 0; i < lower.length; i++) {
-        if (lower[i].includes(w) || w.includes(lower[i]))
-            return candidates[i];
-    }
-    let prefixBest;
-    let prefixLen = 0;
-    for (let i = 0; i < lower.length; i++) {
-        let n = 0;
-        while (n < w.length && n < lower[i].length && w[n] === lower[i][n])
-            n++;
-        if (n > prefixLen) {
-            prefixLen = n;
-            prefixBest = candidates[i];
-        }
-    }
-    if (prefixBest && prefixLen >= Math.max(4, Math.ceil(w.length / 2))) {
-        return prefixBest;
-    }
-    let best;
-    let bestScore = Infinity;
-    const tolerance = Math.max(2, Math.floor(w.length / 3));
-    for (let i = 0; i < lower.length; i++) {
-        const d = editDistance(w, lower[i]);
-        if (d < bestScore) {
-            bestScore = d;
-            best = candidates[i];
-        }
-    }
-    return bestScore <= tolerance ? best : undefined;
-}
-exports.nearest = nearest;
+"use strict";
+/**
+ * Nearest-candidate matching for "did you mean…" suggestions on validation
+ * errors — an unknown field or dropdown value is rejected WITH the closest
+ * real name, so an honest error is also an actionable one.
+ *
+ * Substring matching alone is not enough: the canonical case is
+ * `SerialNo` → `SerialNumber`, and "serialno" is NOT a substring of
+ * "serialnumber" (…n-o… vs …n-u…) nor within any sane edit-distance
+ * tolerance (5 edits). The longest-shared-prefix pass is what makes that
+ * documented case actually produce a suggestion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nearest = void 0;
+function editDistance(a, b) {
+    const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    const cur = new Array(b.length + 1);
+    for (let i = 1; i <= a.length; i++) {
+        cur[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        prev.splice(0, prev.length, ...cur);
+    }
+    return prev[b.length];
+}
+function nearest(candidates, wanted) {
+    const w = wanted.toLowerCase().trim();
+    if (!w)
+        return undefined;
+    const lower = candidates.map((c) => c.toLowerCase());
+    const exact = lower.indexOf(w);
+    if (exact >= 0)
+        return candidates[exact];
+    for (let i = 0; i < lower.length; i++) {
+        if (lower[i].startsWith(w) || w.startsWith(lower[i]))
+            return candidates[i];
+    }
+    for (let i = 0; i < lower.length; i++) {
+        if (lower[i].includes(w) || w.includes(lower[i]))
+            return candidates[i];
+    }
+    let prefixBest;
+    let prefixLen = 0;
+    for (let i = 0; i < lower.length; i++) {
+        let n = 0;
+        while (n < w.length && n < lower[i].length && w[n] === lower[i][n])
+            n++;
+        if (n > prefixLen) {
+            prefixLen = n;
+            prefixBest = candidates[i];
+        }
+    }
+    if (prefixBest && prefixLen >= Math.max(4, Math.ceil(w.length / 2))) {
+        return prefixBest;
+    }
+    let best;
+    let bestScore = Infinity;
+    const tolerance = Math.max(2, Math.floor(w.length / 3));
+    for (let i = 0; i < lower.length; i++) {
+        const d = editDistance(w, lower[i]);
+        if (d < bestScore) {
+            bestScore = d;
+            best = candidates[i];
+        }
+    }
+    return bestScore <= tolerance ? best : undefined;
+}
+exports.nearest = nearest;
 //# sourceMappingURL=suggest.js.map

package/dist/types.d.ts

@@ -1,111 +1,111 @@
-import { FieldDataType, SemanticQueryEntityType } from '@spotto/contract';
-/**
- * What an organisation's catalogue looks like to this package.
- *
- * These are NOT wire shapes — the wire contract lives in `@spotto/contract`.
- * This is the vocabulary a query is resolved AGAINST: which custom fields
- * exist, what type each one is, and (for the evaluator) the type documents
- * whose values an asset inherits.
- */
-export interface SemanticFieldDef {
-    /** The field's id — custom-field matching is by `_id`, not name. */
-    id: string;
-    name: string;
-    dataType: FieldDataType;
-    /** Dropdown options — an eq value must match one exactly or the query silently returns nothing. */
-    options?: string[];
-}
-/** A resolved type-level field value, as materialised in `typeFieldValuesAll`. */
-export interface SemanticTypeFieldValue {
-    _id?: string;
-    name?: string;
-    valueString?: string;
-    valueInteger?: number;
-    valueDecimal?: number;
-    valueBoolean?: boolean;
-    valueDate?: number;
-}
-export interface SemanticTypeDef {
-    id: string;
-    /** Pipe-delimited, pipe-terminated. Root type is "". */
-    path: string;
-    /** Inheritance already resolved by the platform. */
-    typeFieldValuesAll: SemanticTypeFieldValue[];
-}
-/**
- * A NAMED record a condition can point at by name instead of by id.
- *
- * This is how the event vocabulary escapes the producer gap without repeating
- * its mistake. An id cannot be asked of a model — it would be invented, and an
- * invented id runs and matches nothing. A NAME can be asked for, but only if
- * it is resolved against real records and an unresolvable or ambiguous one
- * FAILS: the moment resolution silently picks a candidate, or falls back to a
- * regex, it becomes the same silent-wrong-rows problem wearing a friendlier
- * face.
- *
- * Safe here and not for assets purely because of cardinality. Users, readers
- * and actions are small named catalogues that fit in a prompt and resolve
- * unambiguously; assets number in the thousands and share name stems
- * ("BC-A1" is a prefix of "BC-A10").
- */
-export interface SemanticNamedRef {
-    id: string;
-    name: string;
-    /** Shown to a user in a suggestion when the name does not resolve. */
-    label?: string;
-}
-/**
- * What VALIDATION needs: field definitions, plus the named catalogues the
- * event vocabulary resolves against. Empty catalogues are legitimate — a
- * caller that never validates event conditions supplies none, and one that
- * does gets an honest "no one called that" rather than a match on nothing.
- */
-export interface SemanticFieldCatalogue {
-    fields: SemanticFieldDef[];
-    /** Organisation users — resolves `{type:'user', name}`. */
-    users?: SemanticNamedRef[];
-    /** Readers — resolves `{type:'reader', name}`. */
-    readers?: SemanticNamedRef[];
-    /** Form actions — resolves `{type:'action', name}`. */
-    actions?: SemanticNamedRef[];
-}
-/**
- * What EVALUATION needs: the catalogue plus types, because matching a
- * type-level field value in memory means walking the asset's type document.
- * (The Mongo compiler gets the same values through a `$lookup` instead.)
- */
-export interface SemanticAccountSchema extends SemanticFieldCatalogue {
-    types: SemanticTypeDef[];
-}
-export interface SemanticValidationIssue {
-    path: string;
-    code: string;
-    message: string;
-    suggestion?: string;
-}
-export declare class SemanticQueryValidationError extends Error {
-    issues: SemanticValidationIssue[];
-    constructor(issues: SemanticValidationIssue[]);
-}
-/**
- * Throw one validation issue — fail-fast, this package's contract (the issues
- * array shape exists for the wire; internally the FIRST problem is the
- * answer). One helper beside the error class it throws, so issue construction
- * cannot drift between layers.
- */
-export declare function failSemanticValidation(path: string, code: string, message: string, suggestion?: string): never;
-export interface SemanticCompileOptions {
-    /**
-     * Explicit — never sampled deeper than the entry point, so a run is
-     * reproducible: the same query, catalogue, `now` and timezone always give
-     * the same answer, whoever is asking.
-     */
-    now?: Date;
-    /** IANA zone for resolving relative dates. */
-    timeZone?: string;
-    /**
-     * Which entity's vocabulary applies. Defaults to `asset` — the only entity
-     * that executes today, and what every existing caller means.
-     */
-    entityType?: SemanticQueryEntityType;
-}
+import { FieldDataType, SemanticQueryEntityType } from '@spotto/contract';
+/**
+ * What an organisation's catalogue looks like to this package.
+ *
+ * These are NOT wire shapes — the wire contract lives in `@spotto/contract`.
+ * This is the vocabulary a query is resolved AGAINST: which custom fields
+ * exist, what type each one is, and (for the evaluator) the type documents
+ * whose values an asset inherits.
+ */
+export interface SemanticFieldDef {
+    /** The field's id — custom-field matching is by `_id`, not name. */
+    id: string;
+    name: string;
+    dataType: FieldDataType;
+    /** Dropdown options — an eq value must match one exactly or the query silently returns nothing. */
+    options?: string[];
+}
+/** A resolved type-level field value, as materialised in `typeFieldValuesAll`. */
+export interface SemanticTypeFieldValue {
+    _id?: string;
+    name?: string;
+    valueString?: string;
+    valueInteger?: number;
+    valueDecimal?: number;
+    valueBoolean?: boolean;
+    valueDate?: number;
+}
+export interface SemanticTypeDef {
+    id: string;
+    /** Pipe-delimited, pipe-terminated. Root type is "". */
+    path: string;
+    /** Inheritance already resolved by the platform. */
+    typeFieldValuesAll: SemanticTypeFieldValue[];
+}
+/**
+ * A NAMED record a condition can point at by name instead of by id.
+ *
+ * This is how the event vocabulary escapes the producer gap without repeating
+ * its mistake. An id cannot be asked of a model — it would be invented, and an
+ * invented id runs and matches nothing. A NAME can be asked for, but only if
+ * it is resolved against real records and an unresolvable or ambiguous one
+ * FAILS: the moment resolution silently picks a candidate, or falls back to a
+ * regex, it becomes the same silent-wrong-rows problem wearing a friendlier
+ * face.
+ *
+ * Safe here and not for assets purely because of cardinality. Users, readers
+ * and actions are small named catalogues that fit in a prompt and resolve
+ * unambiguously; assets number in the thousands and share name stems
+ * ("BC-A1" is a prefix of "BC-A10").
+ */
+export interface SemanticNamedRef {
+    id: string;
+    name: string;
+    /** Shown to a user in a suggestion when the name does not resolve. */
+    label?: string;
+}
+/**
+ * What VALIDATION needs: field definitions, plus the named catalogues the
+ * event vocabulary resolves against. Empty catalogues are legitimate — a
+ * caller that never validates event conditions supplies none, and one that
+ * does gets an honest "no one called that" rather than a match on nothing.
+ */
+export interface SemanticFieldCatalogue {
+    fields: SemanticFieldDef[];
+    /** Organisation users — resolves `{type:'user', name}`. */
+    users?: SemanticNamedRef[];
+    /** Readers — resolves `{type:'reader', name}`. */
+    readers?: SemanticNamedRef[];
+    /** Form actions — resolves `{type:'action', name}`. */
+    actions?: SemanticNamedRef[];
+}
+/**
+ * What EVALUATION needs: the catalogue plus types, because matching a
+ * type-level field value in memory means walking the asset's type document.
+ * (The Mongo compiler gets the same values through a `$lookup` instead.)
+ */
+export interface SemanticAccountSchema extends SemanticFieldCatalogue {
+    types: SemanticTypeDef[];
+}
+export interface SemanticValidationIssue {
+    path: string;
+    code: string;
+    message: string;
+    suggestion?: string;
+}
+export declare class SemanticQueryValidationError extends Error {
+    issues: SemanticValidationIssue[];
+    constructor(issues: SemanticValidationIssue[]);
+}
+/**
+ * Throw one validation issue — fail-fast, this package's contract (the issues
+ * array shape exists for the wire; internally the FIRST problem is the
+ * answer). One helper beside the error class it throws, so issue construction
+ * cannot drift between layers.
+ */
+export declare function failSemanticValidation(path: string, code: string, message: string, suggestion?: string): never;
+export interface SemanticCompileOptions {
+    /**
+     * Explicit — never sampled deeper than the entry point, so a run is
+     * reproducible: the same query, catalogue, `now` and timezone always give
+     * the same answer, whoever is asking.
+     */
+    now?: Date;
+    /** IANA zone for resolving relative dates. */
+    timeZone?: string;
+    /**
+     * Which entity's vocabulary applies. Defaults to `asset` — the only entity
+     * that executes today, and what every existing caller means.
+     */
+    entityType?: SemanticQueryEntityType;
+}

package/dist/types.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.failSemanticValidation = exports.SemanticQueryValidationError = void 0;
-class SemanticQueryValidationError extends Error {
-    constructor(issues) {
-        super(issues.map((i) => i.message).join('; '));
-        this.issues = issues;
-        this.name = 'SemanticQueryValidationError';
-    }
-}
-exports.SemanticQueryValidationError = SemanticQueryValidationError;
-/**
- * Throw one validation issue — fail-fast, this package's contract (the issues
- * array shape exists for the wire; internally the FIRST problem is the
- * answer). One helper beside the error class it throws, so issue construction
- * cannot drift between layers.
- */
-function failSemanticValidation(path, code, message, suggestion) {
-    throw new SemanticQueryValidationError([
-        suggestion ? { path, code, message, suggestion } : { path, code, message },
-    ]);
-}
-exports.failSemanticValidation = failSemanticValidation;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.failSemanticValidation = exports.SemanticQueryValidationError = void 0;
+class SemanticQueryValidationError extends Error {
+    constructor(issues) {
+        super(issues.map((i) => i.message).join('; '));
+        this.issues = issues;
+        this.name = 'SemanticQueryValidationError';
+    }
+}
+exports.SemanticQueryValidationError = SemanticQueryValidationError;
+/**
+ * Throw one validation issue — fail-fast, this package's contract (the issues
+ * array shape exists for the wire; internally the FIRST problem is the
+ * answer). One helper beside the error class it throws, so issue construction
+ * cannot drift between layers.
+ */
+function failSemanticValidation(path, code, message, suggestion) {
+    throw new SemanticQueryValidationError([
+        suggestion ? { path, code, message, suggestion } : { path, code, message },
+    ]);
+}
+exports.failSemanticValidation = failSemanticValidation;
 //# sourceMappingURL=types.js.map