uql-orm 0.67.0 → 0.68.0

package/dist/mysql/mysqlDialect.d.ts

@@ -1,4 +1,6 @@
+import type { JsonSlot } from '../dialect/jsonSql.js';
 import { MysqlLikeSqlDialect } from '../dialect/mysqlLikeSqlDialect.js';
+import type { QueryContext } from '../type/index.js';
 export declare class MySqlDialect extends MysqlLikeSqlDialect {
     readonly dialectName = "mysql";
     /**
@@ -6,6 +8,19 @@ export declare class MySqlDialect extends MysqlLikeSqlDialect {
      * "subject to removal in a future version"; aliasing the inserted row (8.0.19+) is its replacement.
      */
     protected readonly upsertNewRowAlias = "_uql_new";
-    /** A `SET_VAR` hint, which MySQL reads only in a statement's first `SELECT`. */
+    /**
+     * 26.7 may plan the correlated `JSON_TABLE` as a semijoin materialized once for the whole table, which
+     * answers every row with one row's elements. Verified in `mysqlJsonElemMatch.test.ts`.
+     */
+    protected readonly jsonElemHint = "/*+ NO_SEMIJOIN() */";
+    /**
+     * `JSON_OVERLAPS`, which a multi-valued index serves: verified in `mysqlJsonArrayIndex.test.ts`. It reads
+     * a scalar as an array of one, so the value must be an array.
+     */
+    protected jsonAny(ctx: QueryContext, slot: JsonSlot, values: readonly unknown[]): string;
+    /**
+     * A `SET_VAR` hint, which MySQL reads only right after the statement's own `SELECT` keyword - before
+     * `DISTINCT`, and never in a subquery - so it is anchored to the start rather than found.
+     */
     protected applySettings(sql: string, settings: readonly string[]): string;
 }

package/dist/mysql/mysqlDialect.js

@@ -7,8 +7,24 @@ export class MySqlDialect extends MysqlLikeSqlDialect {
      * "subject to removal in a future version"; aliasing the inserted row (8.0.19+) is its replacement.
      */
     upsertNewRowAlias = UPSERT_NEW_ROW_ALIAS;
-    /** A `SET_VAR` hint, which MySQL reads only in a statement's first `SELECT`. */
+    /**
+     * 26.7 may plan the correlated `JSON_TABLE` as a semijoin materialized once for the whole table, which
+     * answers every row with one row's elements. Verified in `mysqlJsonElemMatch.test.ts`.
+     */
+    jsonElemHint = '/*+ NO_SEMIJOIN() */';
+    /**
+     * `JSON_OVERLAPS`, which a multi-valued index serves: verified in `mysqlJsonArrayIndex.test.ts`. It reads
+     * a scalar as an array of one, so the value must be an array.
+     */
+    jsonAny(ctx, slot, values) {
+        const overlaps = `JSON_OVERLAPS(${this.jsonValue(slot)}, ${this.addValue(ctx, JSON.stringify(values))})`;
+        return `(${this.jsonIsArray(slot)} AND ${overlaps})`;
+    }
+    /**
+     * A `SET_VAR` hint, which MySQL reads only right after the statement's own `SELECT` keyword - before
+     * `DISTINCT`, and never in a subquery - so it is anchored to the start rather than found.
+     */
     applySettings(sql, settings) {
-        return sql.replace('SELECT ', `SELECT /*+ ${settings.map((setting) => `SET_VAR(${setting})`).join(' ')} */ `);
+        return sql.replace(/^SELECT /, `SELECT /*+ ${settings.map((setting) => `SET_VAR(${setting})`).join(' ')} */ `);
     }
 }

package/dist/sqlite/sqliteDialect.d.ts

@@ -1,5 +1,6 @@
 import { AbstractSqlDialect, type DerivedRelation, type HydrateKind, type RelationRows } from '../dialect/abstractSqlDialect.js';
-import type { EntityMeta, FieldOptions, QueryContext, QueryPager, QuerySizeComparisonOps, QueryTextSearchOptions, SqlDialectFeatures, Type, VectorDistance, VectorMetric } from '../type/index.js';
+import { type JsonAccessMode, type JsonSlot } from '../dialect/jsonSql.js';
+import type { EntityMeta, FieldOptions, QueryContext, QueryPager, QueryTextSearchOptions, SqlDialectFeatures, Type, VectorDistance, VectorMetric } from '../type/index.js';
 /** What SQLite and the engines derived from it have. */
 export declare const SQLITE_FEATURES: SqlDialectFeatures;
 export declare class SqliteDialect extends AbstractSqlDialect {
@@ -58,25 +59,25 @@ export declare class SqliteDialect extends AbstractSqlDialect {
      * FTS5 virtual table (UQL does not create those; declare it outside your entities).
      */
     protected appendTextSearch<E>(ctx: QueryContext, entity: Type<E>, meta: EntityMeta<E>, search: QueryTextSearchOptions<E>): void;
+    protected jsonLength(slot: JsonSlot): string;
+    /** `JSON_EACH` walks the array at the path itself, each element's `fullkey` naming it from the column. */
+    protected jsonElemFrom(slot: JsonSlot, alias: string): string;
+    protected jsonIsArray(slot: JsonSlot): string;
+    /** An object element's `value` is its JSON text, which its fields are paths into. */
+    protected jsonElemDoc(alias: string): string;
     /**
-     * Each element is read back as JSON text through `->` at its own `fullkey`, so it compares
-     * correctly whatever its type. `JSON_EACH`'s `value` column would not: it unquotes strings (`a`
-     * vs `"a"`), flattens booleans to 0/1, and stringifies objects.
+     * A scalar element's `value` is already typed, so a number and a string compare as such. Its JSON form
+     * is read back from the column at the element's own `fullkey`, since `value` flattens a boolean to 0/1.
      */
-    protected jsonAll(ctx: QueryContext, jsonField: string, value: unknown): string;
-    protected jsonSize(ctx: QueryContext, jsonField: string, value: number | QuerySizeComparisonOps): string;
-    /** `JSON_EACH` yields both scalar and object elements, so one form covers each case. */
-    protected jsonElemFrom(jsonField: string, _fields: readonly string[], alias: string): string;
-    protected jsonElemRef(alias: string, field?: string, asJson?: boolean): string;
-    protected getJsonPathScalarExpr(escapedColumn: string, jsonPathStr: string): string;
+    protected jsonElemValue(slot: JsonSlot, alias: string, mode: JsonAccessMode): string;
+    /** `JSON_EXTRACT` already answers a number as one, and orders it by value. */
+    protected readonly jsonSortModes: readonly JsonAccessMode[];
+    /** `->` for the JSON value, and `JSON_EXTRACT` for SQLite's own: a number as a number, a string as text. */
+    protected jsonPathReading(escapedColumn: string, path: string, mode: 'json' | 'text'): string;
     protected numericCast(expr: string): string;
     protected jsonCast(operand: string): string;
-    /**
-     * `JSON_REPLACE` leaves an absent key (and a NULL column) untouched. Elements are read back
-     * through `->` at their own `fullkey` so each keeps its JSON type - `JSON_EACH`'s `value` would
-     * flatten booleans to 0/1 and stringify objects.
-     */
-    protected jsonPullKey(ctx: QueryContext, expr: string, escapedCol: string, key: string, value: unknown): string;
+    /** `JSON` keeps each element's JSON type in the array, which answers `[]` for no rows. */
+    protected jsonArrayOf(elem: string): string;
     protected jsonSet(ctx: QueryContext, expr: string, set: Record<string, unknown>, field?: FieldOptions): string;
     /** `[#]` appends, creating the array where it is absent: `JSON_SET`, since Turso's `JSON_INSERT` will not touch an existing array. */
     protected jsonPush(ctx: QueryContext, expr: string, push: Record<string, unknown>): string;

package/dist/sqlite/sqliteDialect.js

@@ -1,7 +1,6 @@
 import { AbstractSqlDialect, } from '../dialect/abstractSqlDialect.js';
-import { JSON_ELEM_ALIAS, JSON_PULL_ALIAS } from '../dialect/aliases.js';
 import { BYTES_PREFIX } from '../dialect/hydrateColumn.js';
-import { chainedCall, groupsPerCall, jsonAssignCall, jsonElemExists, jsonPath, jsonRemoveCall, jsonSetTarget, } from '../dialect/jsonSql.js';
+import { chainedCall, groupsPerCall, jsonSetCall, jsonPath, jsonArraySlotArgs, jsonSlotArgs, jsonRemoveCall, jsonSetTarget, } from '../dialect/jsonSql.js';
 import { textSearchFields } from '../util/dialect.util.js';
 import { columnFamily, isIntegerColumn } from '../util/field.util.js';
 /** What SQLite and the engines derived from it have. */
@@ -25,8 +24,6 @@ export const SQLITE_FEATURES = {
     rowLockOf: true,
     orderedUpsertReturning: true,
     orderedJsonAggregates: true,
-    partialJsonContainment: false,
-    typedJsonElements: true,
     narrowVectorTypes: false,
     vectorTuningNeedsTransaction: false,
     serialDeclaresPrimaryKey: true,
@@ -126,32 +123,38 @@ export class SqliteDialect extends AbstractSqlDialect {
         ctx.append(`${this.escapedTableName(meta)} MATCH {${columns.join(' ')}} : `);
         ctx.addValue(search.$value);
     }
+    jsonLength(slot) {
+        return `JSON_ARRAY_LENGTH(${jsonArraySlotArgs(slot, this.jsonIsArray(slot))})`;
+    }
+    /** `JSON_EACH` walks the array at the path itself, each element's `fullkey` naming it from the column. */
+    jsonElemFrom(slot, alias) {
+        return `JSON_EACH(${jsonArraySlotArgs(slot, this.jsonIsArray(slot))}) ${alias}`;
+    }
+    jsonIsArray(slot) {
+        return `JSON_TYPE(${jsonSlotArgs(slot)}) = 'array'`;
+    }
+    /** An object element's `value` is its JSON text, which its fields are paths into. */
+    jsonElemDoc(alias) {
+        return `${alias}.value`;
+    }
     /**
-     * Each element is read back as JSON text through `->` at its own `fullkey`, so it compares
-     * correctly whatever its type. `JSON_EACH`'s `value` column would not: it unquotes strings (`a`
-     * vs `"a"`), flattens booleans to 0/1, and stringifies objects.
+     * A scalar element's `value` is already typed, so a number and a string compare as such. Its JSON form
+     * is read back from the column at the element's own `fullkey`, since `value` flattens a boolean to 0/1.
      */
-    jsonAll(ctx, jsonField, value) {
-        const alias = ctx.claimAlias(JSON_ELEM_ALIAS);
-        const from = this.jsonElemFrom(jsonField, [], alias);
-        const conditions = value.map((val) => jsonElemExists(from, [`${jsonField} -> ${alias}.fullkey = ${this.jsonScalarParam(ctx, val)}`]));
-        return `(${conditions.join(' AND ')})`;
-    }
-    jsonSize(ctx, jsonField, value) {
-        return this.buildFragment(ctx, (fragmentCtx) => this.buildSizeComparison(fragmentCtx, () => fragmentCtx.append(`JSON_ARRAY_LENGTH(${jsonField})`), value));
-    }
-    /** `JSON_EACH` yields both scalar and object elements, so one form covers each case. */
-    jsonElemFrom(jsonField, _fields, alias) {
-        return `JSON_EACH(${jsonField}) ${alias}`;
-    }
-    jsonElemRef(alias, field, asJson = false) {
-        if (field === undefined) {
-            return `${alias}.value`;
+    jsonElemValue(slot, alias, mode) {
+        if (mode === 'json') {
+            return `${slot.base} -> ${alias}.fullkey`;
         }
-        return asJson ? `${alias}.value -> ${jsonPath(field)}` : `JSON_EXTRACT(${alias}.value, ${jsonPath(field)})`;
+        const value = this.jsonElemDoc(alias);
+        return mode === 'numeric' ? this.numericCast(value) : value;
     }
-    getJsonPathScalarExpr(escapedColumn, jsonPathStr) {
-        return `JSON_EXTRACT(${escapedColumn}, ${jsonPath(jsonPathStr)})`;
+    /** `JSON_EXTRACT` already answers a number as one, and orders it by value. */
+    jsonSortModes = ['text'];
+    /** `->` for the JSON value, and `JSON_EXTRACT` for SQLite's own: a number as a number, a string as text. */
+    jsonPathReading(escapedColumn, path, mode) {
+        return mode === 'json'
+            ? `(${escapedColumn} -> ${jsonPath(path)})`
+            : `JSON_EXTRACT(${escapedColumn}, ${jsonPath(path)})`;
     }
     numericCast(expr) {
         return `CAST(${expr} AS REAL)`;
@@ -159,25 +162,18 @@ export class SqliteDialect extends AbstractSqlDialect {
     jsonCast(operand) {
         return `JSON(${operand})`;
     }
-    /**
-     * `JSON_REPLACE` leaves an absent key (and a NULL column) untouched. Elements are read back
-     * through `->` at their own `fullkey` so each keeps its JSON type - `JSON_EACH`'s `value` would
-     * flatten booleans to 0/1 and stringify objects.
-     */
-    jsonPullKey(ctx, expr, escapedCol, key, value) {
-        const path = jsonPath(key);
-        const elem = `${escapedCol} -> ${JSON_PULL_ALIAS}.fullkey`;
-        const kept = `SELECT JSON_GROUP_ARRAY(JSON(${elem})) FROM JSON_EACH(${escapedCol}, ${path}) ${JSON_PULL_ALIAS} WHERE ${elem} <> ${this.jsonScalarParam(ctx, value)}`;
-        return `JSON_REPLACE(${expr}, ${path}, (${kept}))`;
+    /** `JSON` keeps each element's JSON type in the array, which answers `[]` for no rows. */
+    jsonArrayOf(elem) {
+        return `JSON_GROUP_ARRAY(JSON(${elem}))`;
     }
     jsonSet(ctx, expr, set, field) {
-        return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'JSON_SET', jsonSetTarget(expr, field, `'{}'`), set, this.maxFunctionArgs);
+        return jsonSetCall((value) => this.jsonScalarParam(ctx, value), jsonSetTarget(expr, field, `'{}'`), set, this.maxFunctionArgs);
     }
     /** `[#]` appends, creating the array where it is absent: `JSON_SET`, since Turso's `JSON_INSERT` will not touch an existing array. */
     jsonPush(ctx, expr, push) {
-        return jsonAssignCall((value) => this.jsonScalarParam(ctx, value), 'JSON_SET', expr, push, this.maxFunctionArgs, '[#]');
+        return jsonSetCall((value) => this.jsonScalarParam(ctx, value), expr, push, this.maxFunctionArgs, '[#]');
     }
     jsonUnset(_ctx, expr, unset) {
-        return jsonRemoveCall('JSON_REMOVE', expr, unset, this.maxFunctionArgs);
+        return jsonRemoveCall(expr, unset, this.maxFunctionArgs);
     }
 }

package/dist/type/dialect.d.ts

@@ -135,10 +135,6 @@ export interface SqlDialectFeatures extends DialectFeatures {
     readonly orderedUpsertReturning: boolean;
     /** Whether a JSON aggregate takes an `ORDER BY` of its own; where not, a relation's rows keep their derived table's order. */
     readonly orderedJsonAggregates: boolean;
-    /** Whether JSON array containment matches an object element that merely includes the given keys, as `@>` does. */
-    readonly partialJsonContainment: boolean;
-    /** Whether an exploded scalar JSON element keeps its SQL type, as SQLite's `JSON_EACH` does. */
-    readonly typedJsonElements: boolean;
     /** Whether the engine has pgvector's `halfvec` and `sparsevec`; elsewhere both map onto `vector`. */
     readonly narrowVectorTypes: boolean;
     /** Whether an ANN index's tuning `SET` applies only inside a transaction, as `SET LOCAL` does. */

package/dist/type/entity.d.ts

@@ -181,7 +181,10 @@ export type FieldOptions<V = TsTypeOf<FieldType>, E = unknown> = {
     readonly type?: FieldType;
     /** A vector column's dimensions: `@Field({ type: 'vector', dimensions: 1536 })`. */
     readonly dimensions?: number;
-    /** The metric a vector search on this field uses unless it names its own `$distance`; `'cosine'` by default. */
+    /**
+     * The metric a vector search on this field uses unless it names its own `$distance`; by default its
+     * vector index's metric, else `'cosine'`.
+     */
     readonly distance?: VectorDistance;
     /** The entity this column is a foreign key to. */
     readonly references?: EntityGetter;
@@ -445,10 +448,12 @@ export type IndexJsonPath = {
     readonly path: string;
     /** How the value is read, matching what the queries over it compare against. */
     readonly type: FieldType;
+    /** Length of a string value, which MySQL keys as `CHAR(n)` and so requires. */
+    readonly length?: number;
 };
 /**
- * MySQL's multi-valued index, one key per element of the JSON array at `path`, what `$all` and
- * `$elemMatch` containment use; refused on any other engine.
+ * MySQL's multi-valued index, one key per element of the JSON array at `path`, which `$all` and an
+ * `$elemMatch` on one value or several use; refused on any other engine.
  * @example `@Index((user) => [{ column: user.tags, jsonArray: { type: String, length: 64 } }])`
  */
 export type IndexJsonArray = {

package/dist/type/vector.d.ts

@@ -28,20 +28,18 @@ export interface QueryVectorSearch extends QueryVectorQuery {
  */
 export type WithDistance<E, K extends string = '_distance'> = E & Record<K, number>;
 /**
- * How a dialect spells a metric: an operator with the operator class an index names from it, or a
- * function, `metricArg` where it takes the metric by name. One map, so its keys say which metrics exist.
+ * How a dialect spells a metric: an operator, or a function taking the metric by name where `metricArg`
+ * says so, and `index`, how the dialect's vector index names it where it builds one. One map serves the
+ * query and the index alike, so its keys say which metrics exist.
  */
 export type VectorMetric = {
     readonly op: string;
-    readonly opsSuffix: string;
+    readonly index: string;
 } | {
     readonly fn: string;
     readonly metricArg?: string;
+    readonly index?: string;
 };
-/** The operator form, for the pgvector-family dialects whose index DDL also needs `opsSuffix`. */
-export type VectorOperatorMetric = Extract<VectorMetric, {
-    op: string;
-}>;
 /** The error every dialect throws for a metric it lacks. */
 export declare function unsupportedVectorMetric(dialectName: string, distance: VectorDistance, indexName?: string): TypeError;
 /**

package/dist/util/dialect.util.d.ts

@@ -138,6 +138,8 @@ export declare function parseGroupMap<E>(group?: QueryGroupMap<E>, select?: Quer
  * indices. Shared by the SQL and MongoDB builders, whose `$where` and `$having` all face this.
  */
 export declare function isOperatorMap(value: unknown): value is Record<string, unknown>;
+/** A JSON object, matched by what it holds: a plain object with no operator key. */
+export declare function isJsonObject(value: unknown): value is Record<string, unknown>;
 /**
  * A page operand, checked before it reaches an engine. These arrive from page arithmetic and from
  * REST query strings (`parseQueryParams` yields `NaN` for a non-numeric one), and each engine's own

package/dist/util/dialect.util.js

@@ -3,7 +3,7 @@ import { soleIdOf } from '../entity/metadata/definition.js';
 import { QueryRaw, resolveAggregateOp, SOFT_DELETE_FILTER, } from '../type/index.js';
 import { VECTOR_INDEX_TYPES } from '../type/vector.js';
 import { isDatabaseWritten } from './field.util.js';
-import { entityName, getFieldKeys, getKeys, hasKeys, isScalarId, isRecord, isWhereMap, someKey, } from './object.util.js';
+import { entityName, getFieldKeys, getKeys, hasKeys, isOperatorObject, isScalarId, isRecord, isWhereMap, someKey, } from './object.util.js';
 /** The keys of `payload` a write persists as columns. */
 export function filterFieldKeys(meta, payload, callbackKey) {
     return getKeys(payload).filter((key) => {
@@ -226,7 +226,7 @@ const JSON_UPDATE_OPS = [
 ];
 /** Type guard: checks whether an update payload value is a JSON operator object. */
 export function isJsonUpdateOp(value) {
-    return value !== null && typeof value === 'object' && someKey(value, (key) => JSON_UPDATE_OPS.includes(key));
+    return isRecord(value) && someKey(value, (key) => JSON_UPDATE_OPS.includes(key));
 }
 /**
  * The `$where` naming rows by key: a bare value names the one key column (refused on a composite), a
@@ -386,6 +386,10 @@ export function isOperatorMap(value) {
         !(value instanceof Uint8Array) &&
         !(value instanceof QueryRaw));
 }
+/** A JSON object, matched by what it holds: a plain object with no operator key. */
+export function isJsonObject(value) {
+    return isOperatorMap(value) && !isOperatorObject(value);
+}
 /**
  * A page operand, checked before it reaches an engine. These arrive from page arithmetic and from
  * REST query strings (`parseQueryParams` yields `NaN` for a non-numeric one), and each engine's own

package/dist/util/object.util.d.ts

@@ -9,12 +9,10 @@ export declare function hasKeys<T>(obj: T): obj is NonNullable<T>;
  * without materializing a key array (unlike `Object.keys(obj).some(pred)`).
  */
 export declare function someKey<T extends object>(obj: T, pred: (key: keyof T & string) => boolean): boolean;
-/** Whether any enumerable value of `obj` satisfies `pred`, short-circuiting like {@link someKey}. */
-export declare function someValue(obj: object, pred: (value: unknown) => boolean): boolean;
+/** Whether `key` names an operator (`$eq`, `$push`...) rather than a field. */
+export declare function isOperatorKey(key: string): boolean;
 /** Whether `value` is a non-empty object with an operator key (`$eq`, `$push`...): the one test every dialect classifies with. */
 export declare function isOperatorObject(value: unknown): value is Record<string, unknown>;
-/** Whether every key of the non-empty object `value` is an operator (no plain field names mixed in). */
-export declare function isOperatorOnlyObject(value: unknown): value is Record<string, unknown>;
 /** Whether `value` is an object that is not an array, whose keys can be read. */
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function getKeys<T extends object>(obj: T | null | undefined): (keyof T & string)[];

package/dist/util/object.util.js

@@ -32,18 +32,13 @@ export function someKey(obj, pred) {
     }
     return false;
 }
-/** Whether any enumerable value of `obj` satisfies `pred`, short-circuiting like {@link someKey}. */
-export function someValue(obj, pred) {
-    return someKey(obj, (key) => pred(obj[key]));
+/** Whether `key` names an operator (`$eq`, `$push`...) rather than a field. */
+export function isOperatorKey(key) {
+    return key.startsWith('$');
 }
-const isOperatorKey = (key) => key.startsWith('$');
 /** Whether `value` is a non-empty object with an operator key (`$eq`, `$push`...): the one test every dialect classifies with. */
 export function isOperatorObject(value) {
-    return hasKeys(value) && !Array.isArray(value) && someKey(value, isOperatorKey);
-}
-/** Whether every key of the non-empty object `value` is an operator (no plain field names mixed in). */
-export function isOperatorOnlyObject(value) {
-    return hasKeys(value) && !Array.isArray(value) && !someKey(value, (key) => !isOperatorKey(key));
+    return isRecord(value) && someKey(value, isOperatorKey);
 }
 /** Whether `value` is an object that is not an array, whose keys can be read. */
 export function isRecord(value) {

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.67.0",
+  "version": "0.68.0",
   "type": "module",
   "engines": {
     "node": ">=24"

package/dist/dialect/jsonArrayElemMatchUtils.d.ts

@@ -1,2 +0,0 @@
-/** An `$elemMatch` as per-field conditions, a plain value as `$eq`, so both spellings emit the same SQL. */
-export declare function buildElemMatchConditions(match: Record<string, unknown>, onCondition: (field: string, op: string, value: unknown) => string): string[];

package/dist/dialect/jsonArrayElemMatchUtils.js

@@ -1,7 +0,0 @@
-import { isOperatorObject } from '../util/object.util.js';
-/** An `$elemMatch` as per-field conditions, a plain value as `$eq`, so both spellings emit the same SQL. */
-export function buildElemMatchConditions(match, onCondition) {
-    return Object.entries(match).flatMap(([field, value]) => isOperatorObject(value)
-        ? Object.entries(value).map(([op, opVal]) => onCondition(field, op, opVal))
-        : onCondition(field, '$eq', value));
-}

package/dist/dialect/pgVectorMetrics.d.ts

@@ -1,13 +0,0 @@
-import type { VectorDistance, VectorOperatorMetric } from '../type/index.js';
-/**
- * Each metric's pgvector distance operator and the operator-class suffix its index takes, in one list
- * so a dialect cannot have the operator but not the opclass. Its own module because the two ends live
- * apart: the operator on the dialect, the opclass in the migrator's index DDL.
- */
-export declare const PG_VECTOR_METRICS: ReadonlyMap<VectorDistance, VectorOperatorMetric>;
-/**
- * CockroachDB's three: `<+>` and `vector_l1_ops` answer "unimplemented: operator class ... is not
- * supported" (verified live on v26.2), tracked at https://github.com/cockroachdb/cockroach/issues/147839.
- * Re-check that issue before adding `l1`; it is omitted on purpose.
- */
-export declare const COCKROACH_VECTOR_METRICS: ReadonlyMap<VectorDistance, VectorOperatorMetric>;

package/dist/dialect/pgVectorMetrics.js

@@ -1,17 +0,0 @@
-/**
- * Each metric's pgvector distance operator and the operator-class suffix its index takes, in one list
- * so a dialect cannot have the operator but not the opclass. Its own module because the two ends live
- * apart: the operator on the dialect, the opclass in the migrator's index DDL.
- */
-export const PG_VECTOR_METRICS = new Map([
-    ['cosine', { op: '<=>', opsSuffix: 'cosine' }],
-    ['l2', { op: '<->', opsSuffix: 'l2' }],
-    ['inner', { op: '<#>', opsSuffix: 'ip' }],
-    ['l1', { op: '<+>', opsSuffix: 'l1' }],
-]);
-/**
- * CockroachDB's three: `<+>` and `vector_l1_ops` answer "unimplemented: operator class ... is not
- * supported" (verified live on v26.2), tracked at https://github.com/cockroachdb/cockroach/issues/147839.
- * Re-check that issue before adding `l1`; it is omitted on purpose.
- */
-export const COCKROACH_VECTOR_METRICS = new Map([...PG_VECTOR_METRICS].filter(([metric]) => metric !== 'l1'));

package/dist/maria/mariaVectorMetrics.d.ts

@@ -1,8 +0,0 @@
-import type { VectorDistance } from '../type/index.js';
-/**
- * MariaDB's own name for each metric it supports (`euclidean`, not `l2`), which its index clause and
- * its distance function are both spelled from - one list, so a metric can never be searchable and
- * unindexable or the reverse. Its own module because the two ends now live apart: the distance
- * function on the dialect, the `DISTANCE=` clause in the migrator's index DDL.
- */
-export declare const MARIA_VECTOR_METRICS: Map<VectorDistance, string>;

package/dist/maria/mariaVectorMetrics.js

@@ -1,10 +0,0 @@
-/**
- * MariaDB's own name for each metric it supports (`euclidean`, not `l2`), which its index clause and
- * its distance function are both spelled from - one list, so a metric can never be searchable and
- * unindexable or the reverse. Its own module because the two ends now live apart: the distance
- * function on the dialect, the `DISTANCE=` clause in the migrator's index DDL.
- */
-export const MARIA_VECTOR_METRICS = new Map([
-    ['cosine', 'cosine'],
-    ['l2', 'euclidean'],
-]);