@prisma-next/extension-pgvector 0.5.0-dev.6 → 0.5.0-dev.61

package/package.json

@@ -1,26 +1,28 @@
 {
   "name": "@prisma-next/extension-pgvector",
-  "version": "0.5.0-dev.6",
+  "version": "0.5.0-dev.61",
+  "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.5.0-dev.6",
-    "@prisma-next/contract-authoring": "0.5.0-dev.6",
-    "@prisma-next/family-sql": "0.5.0-dev.6",
-    "@prisma-next/framework-components": "0.5.0-dev.6",
-    "@prisma-next/sql-operations": "0.5.0-dev.6",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.6",
-    "@prisma-next/sql-runtime": "0.5.0-dev.6",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.6"
+    "@prisma-next/contract": "0.5.0-dev.61",
+    "@prisma-next/contract-authoring": "0.5.0-dev.61",
+    "@prisma-next/framework-components": "0.5.0-dev.61",
+    "@prisma-next/sql-operations": "0.5.0-dev.61",
+    "@prisma-next/family-sql": "0.5.0-dev.61",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.61",
+    "@prisma-next/sql-runtime": "0.5.0-dev.61",
+    "@prisma-next/sql-schema-ir": "0.5.0-dev.61"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/operations": "0.5.0-dev.6",
-    "@prisma-next/sql-contract": "0.5.0-dev.6",
-    "@prisma-next/sql-contract-ts": "0.5.0-dev.6",
+    "@prisma-next/operations": "0.5.0-dev.61",
+    "@prisma-next/sql-contract": "0.5.0-dev.61",
+    "@prisma-next/sql-contract-ts": "0.5.0-dev.61",
     "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsdown": "0.0.0",
     "@prisma-next/tsconfig": "0.0.0"

package/src/core/codecs.ts

@@ -1,77 +1,145 @@
 /**
- * Vector codec implementation for pgvector extension.
+ * pgvector extension codec.
  *
- * Provides encoding/decoding for the `vector` PostgreSQL type.
- * Wire format is a string like `[1,2,3]` (PostgreSQL vector text format).
+ * Mirrors the patterns in `postgres/codecs-class.ts` and `sqlite/codecs-class.ts` for the single `pg/vector@1` codec. Three artifacts:
+ *
+ * 1. `PgVectorCodec` extends {@link CodecImpl} with the runtime encode/decode/encodeJson/decodeJson conversions inline. Conversions are simple enough (PostgreSQL `[1,2,3]` text format) that no shared helper module is warranted; the class body is the source of truth.
+ * 2. `PgVectorDescriptor` extends {@link CodecDescriptorImpl} with the codec id, traits, target types, params schema (`{ length: number }`, validated against {@link VECTOR_MAX_DIM}), `meta` (postgres `nativeType: 'vector'`), and the emit-path `renderOutputType` producing `Vector<${length}>`.
+ * 3. `pgVectorColumn(length)` per-codec column helper invoking `descriptor.factory({ length })` directly + passing the bare `nativeType: 'vector'`. The family-layer {@link expandNativeType} hook renders the parameterized form (`vector(1536)`) at emit/verify time from `nativeType` + `typeParams`.
+ *
+ * `length` threads into the runtime codec via the constructor so encode/decode/encodeJson/decodeJson enforce the declared dimension at every ingress path. Without this, `vector(3)` and `vector(1536)` would produce codecs with identical behaviour and a dimension-mismatched value would round-trip undetected.
  */
 
-import { codec, defineCodecs } from '@prisma-next/sql-relational-core/ast';
-
-const pgVectorCodec = codec({
-  typeId: 'pg/vector@1',
-  targetTypes: ['vector'],
-  traits: ['equality'],
-  renderOutputType: (typeParams) => {
-    const length = typeParams['length'];
-    if (length === undefined) return undefined;
-    if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {
-      throw new Error(
-        `renderOutputType: expected positive integer "length" in typeParams for Vector, got ${String(length)}`,
-      );
-    }
-    return `Vector<${length}>`;
-  },
-  encode: (value: number[]): string => {
-    // Validate that value is an array of numbers
+import type { JsonValue } from '@prisma-next/contract/types';
+import {
+  type AnyCodecDescriptor,
+  type CodecCallContext,
+  CodecDescriptorImpl,
+  CodecImpl,
+  type CodecInstanceContext,
+  type ColumnHelperFor,
+  type ColumnHelperForStrict,
+  column,
+} from '@prisma-next/framework-components/codec';
+import type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { type as arktype } from 'arktype';
+import { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from './constants';
+
+type VectorParams = { readonly length: number };
+
+const vectorParamsSchema = arktype({
+  length: 'number',
+}).narrow((params, ctx) => {
+  const { length } = params;
+  if (!Number.isInteger(length)) {
+    return ctx.mustBe('an integer');
+  }
+  if (length < 1 || length > VECTOR_MAX_DIM) {
+    return ctx.mustBe(`in the range [1, ${VECTOR_MAX_DIM}]`);
+  }
+  return true;
+}) satisfies StandardSchemaV1<VectorParams>;
+
+const PG_VECTOR_META = { db: { sql: { postgres: { nativeType: 'vector' } } } } as const;
+
+export class PgVectorCodec extends CodecImpl<
+  typeof VECTOR_CODEC_ID,
+  readonly ['equality'],
+  string,
+  number[]
+> {
+  readonly length: number | undefined;
+
+  constructor(descriptor: AnyCodecDescriptor, length: number | undefined) {
+    super(descriptor);
+    this.length = length;
+  }
+
+  assertVector(value: unknown): asserts value is number[] {
     if (!Array.isArray(value)) {
       throw new Error('Vector value must be an array of numbers');
     }
     if (!value.every((v) => typeof v === 'number')) {
       throw new Error('Vector value must contain only numbers');
     }
-    // Format as PostgreSQL vector text format: [1,2,3]
-    // PostgreSQL's pg library requires the vector format string
+    if (this.length !== undefined && value.length !== this.length) {
+      throw new Error(`Vector length mismatch: expected ${this.length}, got ${value.length}`);
+    }
+  }
+
+  async encode(value: number[], _ctx: CodecCallContext): Promise<string> {
+    this.assertVector(value);
     return `[${value.join(',')}]`;
-  },
-  decode: (wire: string): number[] => {
-    // Handle string format from PostgreSQL: [1,2,3]
+  }
+
+  async decode(wire: string, _ctx: CodecCallContext): Promise<number[]> {
     if (typeof wire !== 'string') {
       throw new Error('Vector wire value must be a string');
     }
-    // Parse PostgreSQL vector format: [1,2,3]
     if (!wire.startsWith('[') || !wire.endsWith(']')) {
       throw new Error(`Invalid vector format: expected "[...]", got "${wire}"`);
     }
     const content = wire.slice(1, -1).trim();
-    if (content === '') {
-      return [];
-    }
-    const values = content.split(',').map((v) => {
-      const num = Number.parseFloat(v.trim());
-      if (Number.isNaN(num)) {
-        throw new Error(`Invalid vector value: "${v}" is not a number`);
-      }
-      return num;
-    });
-    return values;
-  },
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: 'vector',
-        },
-      },
-    },
-  },
-});
-
-// Build codec definitions using the builder DSL
-const codecs = defineCodecs().add('vector', pgVectorCodec);
-
-// Export derived structures directly from codecs builder
-export const codecDefinitions = codecs.codecDefinitions;
-export const dataTypes = codecs.dataTypes;
-
-// Export types derived from codecs builder
-export type CodecTypes = typeof codecs.CodecTypes;
+    const parsed =
+      content === ''
+        ? []
+        : content.split(',').map((v) => {
+            const num = Number.parseFloat(v.trim());
+            if (Number.isNaN(num)) {
+              throw new Error(`Invalid vector value: "${v}" is not a number`);
+            }
+            return num;
+          });
+    this.assertVector(parsed);
+    return parsed;
+  }
+
+  encodeJson(value: number[]): JsonValue {
+    this.assertVector(value);
+    return value;
+  }
+
+  decodeJson(json: JsonValue): number[] {
+    this.assertVector(json);
+    return json;
+  }
+}
+
+export class PgVectorDescriptor extends CodecDescriptorImpl<VectorParams> {
+  override readonly codecId = VECTOR_CODEC_ID;
+  override readonly traits = ['equality'] as const;
+  override readonly targetTypes = ['vector'] as const;
+  override readonly meta = PG_VECTOR_META;
+  override readonly paramsSchema: StandardSchemaV1<VectorParams> = vectorParamsSchema;
+  override renderOutputType(params: VectorParams): string {
+    return `Vector<${params.length}>`;
+  }
+  /**
+   * The runtime calls `factory(undefined)(ctx)` to materialize a representative codec for parameterized descriptors that ship a no-params column variant (here, `vectorColumn` vs `vector(N)`). The runtime cast widens `params` to `unknown`, so guarding with an optional read keeps the typed call site (`factory({ length })`) strict while still producing a length-agnostic codec for representative use. Encode/decode for an undimensioned column run through this representative; the wire format `[v1,v2,...]` is dimension-independent.
+   */
+  override factory(params: VectorParams): (ctx: CodecInstanceContext) => PgVectorCodec {
+    return () => new PgVectorCodec(this, (params as VectorParams | undefined)?.length);
+  }
+}
+
+export const pgVectorDescriptor = new PgVectorDescriptor();
+
+/**
+ * Per-codec column helper for `pg/vector@1`. Generic over `N extends number` so the column site preserves the dimension literal in `typeParams` (e.g. `pgVectorColumn(1536)` packs `typeParams: { length: 1536 }`).
+ *
+ * Passes the bare `nativeType: 'vector'`; the family-layer `expandNativeType` hook renders the parameterized form (`vector(1536)`) at emit/verify time from `nativeType` + `typeParams`.
+ */
+export const pgVectorColumn = <N extends number>(length: N) =>
+  column(pgVectorDescriptor.factory({ length }), pgVectorDescriptor.codecId, { length }, 'vector');
+
+pgVectorColumn satisfies ColumnHelperFor<PgVectorDescriptor>;
+pgVectorColumn satisfies ColumnHelperForStrict<PgVectorDescriptor>;
+
+const codecDescriptorMap = {
+  vector: pgVectorDescriptor,
+} as const;
+
+export type CodecTypes = ExtractCodecTypes<typeof codecDescriptorMap>;
+
+export const codecDescriptors: readonly AnyCodecDescriptor[] = Object.values(codecDescriptorMap);

package/src/core/descriptor-meta.ts

@@ -1,38 +1,65 @@
 import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';
+import {
+  buildOperation,
+  type CodecExpression,
+  type Expression,
+  refsOf,
+  toExpr,
+} from '@prisma-next/sql-relational-core/expression';
 import type { CodecTypes } from '../types/codec-types';
 import { pgvectorAuthoringTypes } from './authoring';
-import { codecDefinitions } from './codecs';
+import { pgvectorCodecRegistry } from './registry';
 
 const pgvectorTypeId = 'pg/vector@1' as const;
 
-export const pgvectorQueryOperations: readonly SqlOperationDescriptor[] = [
-  {
-    method: 'cosineDistance',
-    args: [
-      { codecId: pgvectorTypeId, nullable: false },
-      { codecId: pgvectorTypeId, nullable: false },
-    ],
-    returns: { codecId: 'pg/float8@1', nullable: false },
-    lowering: {
-      targetFamily: 'sql',
-      strategy: 'function',
-      template: '{{self}} <=> {{arg0}}',
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+export function pgvectorQueryOperations<
+  CT extends CodecTypesBase,
+>(): readonly SqlOperationDescriptor[] {
+  return [
+    {
+      method: 'cosineDistance',
+      self: { codecId: pgvectorTypeId },
+      impl: (
+        self: CodecExpression<'pg/vector@1', boolean, CT>,
+        other: CodecExpression<'pg/vector@1', boolean, CT>,
+      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> => {
+        const selfRefs = refsOf(self);
+        return buildOperation({
+          method: 'cosineDistance',
+          args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],
+          returns: { codecId: 'pg/float8@1', nullable: false },
+          lowering: {
+            targetFamily: 'sql',
+            strategy: 'function',
+            template: '{{self}} <=> {{arg0}}',
+          },
+        });
+      },
     },
-  },
-  {
-    method: 'cosineSimilarity',
-    args: [
-      { codecId: pgvectorTypeId, nullable: false },
-      { codecId: pgvectorTypeId, nullable: false },
-    ],
-    returns: { codecId: 'pg/float8@1', nullable: false },
-    lowering: {
-      targetFamily: 'sql',
-      strategy: 'function',
-      template: '1 - ({{self}} <=> {{arg0}})',
+    {
+      method: 'cosineSimilarity',
+      self: { codecId: pgvectorTypeId },
+      impl: (
+        self: CodecExpression<'pg/vector@1', boolean, CT>,
+        other: CodecExpression<'pg/vector@1', boolean, CT>,
+      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> => {
+        const selfRefs = refsOf(self);
+        return buildOperation({
+          method: 'cosineSimilarity',
+          args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],
+          returns: { codecId: 'pg/float8@1', nullable: false },
+          lowering: {
+            targetFamily: 'sql',
+            strategy: 'function',
+            template: '1 - ({{self}} <=> {{arg0}})',
+          },
+        });
+      },
     },
-  },
-];
+  ];
+}
 
 const pgvectorPackMetaBase = {
   kind: 'extension',
@@ -50,7 +77,7 @@ const pgvectorPackMetaBase = {
   },
   types: {
     codecTypes: {
-      codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
+      codecDescriptors: Array.from(pgvectorCodecRegistry.values()),
       import: {
         package: '@prisma-next/extension-pgvector/codec-types',
         named: 'CodecTypes',

package/src/core/registry.ts

@@ -0,0 +1,11 @@
+import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
+import type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
+import { codecDescriptors } from './codecs';
+
+/**
+ * Registry of every codec descriptor shipped by `@prisma-next/extension-pgvector`.
+ *
+ * Public consumer surface for the pgvector codec set. Currently a single entry (`pg/vector@1`); the registry shape stays consistent with the other codec-shipping packages so consumers don't need to special-case extensions. See ADR 208.
+ */
+export const pgvectorCodecRegistry: CodecDescriptorRegistry =
+  buildCodecDescriptorRegistry(codecDescriptors);

package/src/exports/column-types.ts

@@ -1,16 +1,14 @@
 /**
  * Column type descriptors for pgvector extension.
  *
- * These descriptors provide both codecId and nativeType for use in contract authoring.
- * They are derived from the same source of truth as codec definitions and manifests.
+ * These descriptors provide both codecId and nativeType for use in contract authoring. They are derived from the same source of truth as codec definitions and manifests.
  */
 
-import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
+import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from '../core/constants';
 
 /**
- * Static vector column descriptor without dimension.
- * Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
+ * Static vector column descriptor without dimension. Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
  */
 export const vectorColumn = {
   codecId: VECTOR_CODEC_ID,
@@ -25,7 +23,6 @@ export const vectorColumn = {
  * .column('embedding', { type: vector(1536), nullable: false })
  * // Produces: nativeType: 'vector', typeParams: { length: 1536 }
  * ```
- *
  * @param length - The dimension of the vector (e.g., 1536 for OpenAI embeddings)
  * @returns A column type descriptor with `typeParams.length` set
  * @throws {RangeError} If length is not an integer in the range [1, VECTOR_MAX_DIM]

package/src/exports/control.ts

@@ -75,7 +75,7 @@ const pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {
       },
     },
   },
-  queryOperations: () => pgvectorQueryOperations,
+  queryOperations: () => pgvectorQueryOperations(),
   databaseDependencies: pgvectorDatabaseDependencies,
   create: () => ({
     familyId: 'sql' as const,

package/src/exports/runtime.ts

@@ -1,42 +1,6 @@
-import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
-import type {
-  RuntimeParameterizedCodecDescriptor,
-  SqlRuntimeExtensionDescriptor,
-} from '@prisma-next/sql-runtime';
-import { type as arktype } from 'arktype';
-import { codecDefinitions } from '../core/codecs';
-import { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from '../core/constants';
+import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';
 import { pgvectorPackMeta, pgvectorQueryOperations } from '../core/descriptor-meta';
-
-const vectorParamsSchema = arktype({
-  length: 'number',
-}).narrow((params, ctx) => {
-  const { length } = params;
-  if (!Number.isInteger(length)) {
-    return ctx.mustBe('an integer');
-  }
-  if (length < 1 || length > VECTOR_MAX_DIM) {
-    return ctx.mustBe(`in the range [1, ${VECTOR_MAX_DIM}]`);
-  }
-  return true;
-});
-
-const parameterizedCodecDescriptors = [
-  {
-    codecId: VECTOR_CODEC_ID,
-    paramsSchema: vectorParamsSchema,
-  },
-] as const satisfies ReadonlyArray<
-  RuntimeParameterizedCodecDescriptor<{ readonly length: number }>
->;
-
-function createPgvectorCodecRegistry() {
-  const registry = createCodecRegistry();
-  for (const def of Object.values(codecDefinitions)) {
-    registry.register(def.codec);
-  }
-  return registry;
-}
+import { pgvectorCodecRegistry } from '../core/registry';
 
 const pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
   kind: 'extension' as const,
@@ -44,9 +8,14 @@ const pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
   version: pgvectorPackMeta.version,
   familyId: 'sql' as const,
   targetId: 'postgres' as const,
-  codecs: createPgvectorCodecRegistry,
-  queryOperations: () => pgvectorQueryOperations,
-  parameterizedCodecs: () => parameterizedCodecDescriptors,
+  // Expose the unified descriptor list so `extractCodecLookup` reads `targetTypes` / `meta` / `renderOutputType` directly off the descriptors and materializes the representative `Codec` for the SQL renderer's cast-policy lookup.
+  types: {
+    codecTypes: {
+      codecDescriptors: Array.from(pgvectorCodecRegistry.values()),
+    },
+  },
+  codecs: () => Array.from(pgvectorCodecRegistry.values()),
+  queryOperations: () => pgvectorQueryOperations(),
   create() {
     return {
       familyId: 'sql' as const,
@@ -55,4 +24,5 @@ const pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
   },
 };
 
+export { pgvectorCodecRegistry };
 export default pgvectorRuntimeDescriptor;

package/src/types/operation-types.ts

@@ -1,4 +1,7 @@
 import type { SqlQueryOperationTypes } from '@prisma-next/sql-contract/types';
+import type { CodecExpression, Expression } from '@prisma-next/sql-relational-core/expression';
+
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
 
 /**
  * Operation type definitions for pgvector extension.
@@ -10,40 +13,31 @@ import type { SqlQueryOperationTypes } from '@prisma-next/sql-contract/types';
 export type OperationTypes = {
   readonly 'pg/vector@1': {
     readonly cosineDistance: {
-      readonly args: readonly [{ readonly codecId: 'pg/vector@1'; readonly nullable: false }];
-      readonly returns: { readonly codecId: 'pg/float8@1'; readonly nullable: false };
-      readonly lowering: {
-        readonly targetFamily: 'sql';
-        readonly strategy: 'function';
-        readonly template: string;
-      };
+      readonly self: { readonly codecId: 'pg/vector@1' };
     };
     readonly cosineSimilarity: {
-      readonly args: readonly [{ readonly codecId: 'pg/vector@1'; readonly nullable: false }];
-      readonly returns: { readonly codecId: 'pg/float8@1'; readonly nullable: false };
-      readonly lowering: {
-        readonly targetFamily: 'sql';
-        readonly strategy: 'function';
-        readonly template: string;
-      };
+      readonly self: { readonly codecId: 'pg/vector@1' };
     };
   };
 };
 
 /** Flat operation signatures for the query builder. */
-export type QueryOperationTypes = SqlQueryOperationTypes<{
-  readonly cosineDistance: {
-    readonly args: readonly [
-      { readonly codecId: 'pg/vector@1'; readonly nullable: boolean },
-      { readonly codecId: 'pg/vector@1'; readonly nullable: boolean },
-    ];
-    readonly returns: { readonly codecId: 'pg/float8@1'; readonly nullable: false };
-  };
-  readonly cosineSimilarity: {
-    readonly args: readonly [
-      { readonly codecId: 'pg/vector@1'; readonly nullable: boolean },
-      { readonly codecId: 'pg/vector@1'; readonly nullable: boolean },
-    ];
-    readonly returns: { readonly codecId: 'pg/float8@1'; readonly nullable: false };
-  };
-}>;
+export type QueryOperationTypes<CT extends CodecTypesBase> = SqlQueryOperationTypes<
+  CT,
+  {
+    readonly cosineDistance: {
+      readonly self: { readonly codecId: 'pg/vector@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/vector@1', boolean, CT>,
+        other: CodecExpression<'pg/vector@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/float8@1'; nullable: false }>;
+    };
+    readonly cosineSimilarity: {
+      readonly self: { readonly codecId: 'pg/vector@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/vector@1', boolean, CT>,
+        other: CodecExpression<'pg/vector@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/float8@1'; nullable: false }>;
+    };
+  }
+>;

package/dist/codec-types-BifaP625.d.mts

@@ -1,27 +0,0 @@
-import * as _prisma_next_sql_relational_core_ast0 from "@prisma-next/sql-relational-core/ast";
-
-//#region src/core/codecs.d.ts
-
-/**
- * Vector codec implementation for pgvector extension.
- *
- * Provides encoding/decoding for the `vector` PostgreSQL type.
- * Wire format is a string like `[1,2,3]` (PostgreSQL vector text format).
- */
-declare const codecs: _prisma_next_sql_relational_core_ast0.CodecDefBuilder<{} & Record<"vector", _prisma_next_sql_relational_core_ast0.Codec<"pg/vector@1", readonly ["equality"], string, number[], Record<string, unknown>, unknown>>>;
-type CodecTypes$1 = typeof codecs.CodecTypes;
-//#endregion
-//#region src/types/codec-types.d.ts
-/**
- * Type-level branded vector.
- *
- * The runtime values are plain number arrays, but parameterized column typing can
- * carry the dimension at the type level (e.g. Vector<1536>).
- */
-type Vector<N extends number = number> = number[] & {
-  readonly __vectorLength?: N;
-};
-type CodecTypes = CodecTypes$1;
-//#endregion
-export { Vector as n, CodecTypes as t };
-//# sourceMappingURL=codec-types-BifaP625.d.mts.map

package/dist/codec-types-BifaP625.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-BifaP625.d.mts","names":[],"sources":["../src/core/codecs.ts","../src/types/codec-types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAqEY;;;cAAN,MAAM,EAAA,qCAAA,CAAA,eAAA,CAAA,CAAA,CAAA,GAAA,MAAA,CAAA,QAAA,EAAA,qCAAA,CAAA,KAAA,CAAA,aAAA,EAAA,SAAA,CAAA,UAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,EAAA,MAAA,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,CAAA,CAAA;KAOA,YAAA,UAAoB,MAAA,CAAO;;;AAAvC;;;;AC3DA;AAEA;KAFY;4BAA2E;;KAE3E,UAAA,GAAa"}