@nicia-ai/typegraph 0.32.0 → 0.34.0

package/dist/chunk-K34OPSJK.js

@@ -0,0 +1,29 @@
+import { FNV1A_OFFSET_BASIS, FNV1A_PRIME } from './chunk-2EBMPJBO.js';
+
+// src/utils/hash.ts
+function fnv1aBase36(input) {
+  let hash = FNV1A_OFFSET_BASIS;
+  for (const character of input) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint === void 0) continue;
+    hash ^= codePoint;
+    hash = Math.imul(hash, FNV1A_PRIME);
+  }
+  return (hash >>> 0).toString(36);
+}
+async function sha256Hex(input, byteLength = 8) {
+  const encoded = new TextEncoder().encode(input);
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", encoded);
+  const bytes = new Uint8Array(digest);
+  let hex = "";
+  for (let index = 0; index < byteLength; index++) {
+    const byte = bytes[index];
+    if (byte === void 0) break;
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+export { fnv1aBase36, sha256Hex };
+//# sourceMappingURL=chunk-K34OPSJK.js.map
+//# sourceMappingURL=chunk-K34OPSJK.js.map

package/dist/chunk-K34OPSJK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/hash.ts"],"names":[],"mappings":";;;AAWO,SAAS,YAAY,KAAA,EAAuB;AACjD,EAAA,IAAI,IAAA,GAAO,kBAAA;AACX,EAAA,KAAA,MAAW,aAAa,KAAA,EAAO;AAC7B,IAAA,MAAM,SAAA,GAAY,SAAA,CAAU,WAAA,CAAY,CAAC,CAAA;AACzC,IAAA,IAAI,cAAc,MAAA,EAAW;AAC7B,IAAA,IAAA,IAAQ,SAAA;AACR,IAAA,IAAA,GAAO,IAAA,CAAK,IAAA,CAAK,IAAA,EAAM,WAAW,CAAA;AAAA,EACpC;AACA,EAAA,OAAA,CAAQ,IAAA,KAAS,CAAA,EAAG,QAAA,CAAS,EAAE,CAAA;AACjC;AAWA,eAAsB,SAAA,CACpB,KAAA,EACA,UAAA,GAAa,CAAA,EACI;AACjB,EAAA,MAAM,OAAA,GAAU,IAAI,WAAA,EAAY,CAAE,OAAO,KAAK,CAAA;AAC9C,EAAA,MAAM,SAAS,MAAM,UAAA,CAAW,OAAO,MAAA,CAAO,MAAA,CAAO,WAAW,OAAO,CAAA;AACvE,EAAA,MAAM,KAAA,GAAQ,IAAI,UAAA,CAAW,MAAM,CAAA;AACnC,EAAA,IAAI,GAAA,GAAM,EAAA;AACV,EAAA,KAAA,IAAS,KAAA,GAAQ,CAAA,EAAG,KAAA,GAAQ,UAAA,EAAY,KAAA,EAAA,EAAS;AAC/C,IAAA,MAAM,IAAA,GAAO,MAAM,KAAK,CAAA;AACxB,IAAA,IAAI,SAAS,MAAA,EAAW;AACxB,IAAA,GAAA,IAAO,KAAK,QAAA,CAAS,EAAE,CAAA,CAAE,QAAA,CAAS,GAAG,GAAG,CAAA;AAAA,EAC1C;AACA,EAAA,OAAO,GAAA;AACT","file":"chunk-K34OPSJK.js","sourcesContent":["/**\n * Hash utilities — FNV-1a for fast non-cryptographic identifier\n * generation, SHA-256 (truncated) for collision-resistant signatures.\n */\nimport { FNV1A_OFFSET_BASIS, FNV1A_PRIME } from \"../constants\";\n\n/**\n * FNV-1a hash of `input`, returned as a base-36 encoded string. Used for\n * generating short, deterministic identifiers (column aliases, index\n * name suffixes, etc.).\n */\nexport function fnv1aBase36(input: string): string {\n  let hash = FNV1A_OFFSET_BASIS;\n  for (const character of input) {\n    const codePoint = character.codePointAt(0);\n    if (codePoint === undefined) continue;\n    hash ^= codePoint;\n    hash = Math.imul(hash, FNV1A_PRIME);\n  }\n  return (hash >>> 0).toString(36);\n}\n\n/**\n * Hex-truncated SHA-256 of `input` via the Web Crypto API. Works in\n * Node.js 16+, Cloudflare Workers, Deno, and browsers.\n *\n * `byteLength` controls how many bytes of the digest are emitted —\n * default 8 (16 hex chars, ~64 bits, sufficient for schema-version and\n * per-graph index signatures). Pass 16 (32 hex chars) when hashes are\n * compared against externally-stored signatures.\n */\nexport async function sha256Hex(\n  input: string,\n  byteLength = 8,\n): Promise<string> {\n  const encoded = new TextEncoder().encode(input);\n  const digest = await globalThis.crypto.subtle.digest(\"SHA-256\", encoded);\n  const bytes = new Uint8Array(digest);\n  let hex = \"\";\n  for (let index = 0; index < byteLength; index++) {\n    const byte = bytes[index];\n    if (byte === undefined) break;\n    hex += byte.toString(16).padStart(2, \"0\");\n  }\n  return hex;\n}\n"]}

package/dist/{chunk-YW7GHMF4.cjs → chunk-KGC4LY5T.cjs}

@@ -1,6 +1,7 @@
 'use strict';
 
-var chunkCFNT3ITG_cjs = require('./chunk-CFNT3ITG.cjs');
+var chunk2JXB3NYJ_cjs = require('./chunk-2JXB3NYJ.cjs');
+var chunkYAZE7QZR_cjs = require('./chunk-YAZE7QZR.cjs');
 var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
 
@@ -72,7 +73,7 @@ function operatorClass(metric) {
   }
 }
 function vectorLiteral(embedding, name) {
-  chunkCFNT3ITG_cjs.assertFiniteEmbedding(embedding, name);
+  chunk2JXB3NYJ_cjs.assertFiniteEmbedding(embedding, name);
   return drizzleOrm.sql`${formatVector(embedding)}::vector`;
 }
 function distanceExpression(embeddingColumn, queryEmbedding, metric) {
@@ -97,11 +98,11 @@ var pgvectorStrategy = {
   name: "pgvector",
   capabilities: PGVECTOR_CAPABILITIES,
   tableName(graphId, nodeKind, fieldPath) {
-    return chunkCFNT3ITG_cjs.vectorPhysicalName(TABLE_PREFIX, graphId, nodeKind, fieldPath);
+    return chunk2JXB3NYJ_cjs.vectorPhysicalName(TABLE_PREFIX, graphId, nodeKind, fieldPath);
   },
   ownedTables(slot) {
     const table = this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath);
-    const name = chunkCFNT3ITG_cjs.quoteIdentifier(table);
+    const name = chunk2JXB3NYJ_cjs.quoteIdentifier(table);
     const createDdl = [
       `CREATE TABLE IF NOT EXISTS ${name} (
   "graph_id" TEXT NOT NULL,
@@ -114,7 +115,7 @@ var pgvectorStrategy = {
     ];
     return [
       {
-        logicalName: `${chunkCFNT3ITG_cjs.VECTOR_CONTRIBUTION_PREFIX}:${slot.nodeKind}.${slot.fieldPath}`,
+        logicalName: `${chunk2JXB3NYJ_cjs.VECTOR_CONTRIBUTION_PREFIX}:${slot.nodeKind}.${slot.fieldPath}`,
         owner: "pgvector",
         tableName: table,
         createDdl,
@@ -123,7 +124,7 @@ var pgvectorStrategy = {
     ];
   },
   buildUpsert(slot, params, timestamp) {
-    const table = chunkCFNT3ITG_cjs.quotedTableName(
+    const table = chunkYAZE7QZR_cjs.quotedTableName(
       this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
     const value = vectorLiteral(params.embedding, "embedding");
@@ -137,7 +138,7 @@ var pgvectorStrategy = {
     ];
   },
   buildDelete(slot, params) {
-    const table = chunkCFNT3ITG_cjs.quotedTableName(
+    const table = chunkYAZE7QZR_cjs.quotedTableName(
       this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
     return [
@@ -148,7 +149,7 @@ var pgvectorStrategy = {
     ];
   },
   buildSearch(slot, params) {
-    const table = chunkCFNT3ITG_cjs.quotedTableName(
+    const table = chunkYAZE7QZR_cjs.quotedTableName(
       this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
     const embeddingColumn = drizzleOrm.sql`${table}."embedding"`;
@@ -157,11 +158,11 @@ var pgvectorStrategy = {
       params.queryEmbedding,
       params.metric
     );
-    const score = chunkCFNT3ITG_cjs.vectorScoreExpression(distance, params.metric);
+    const score = chunk2JXB3NYJ_cjs.vectorScoreExpression(distance, params.metric);
     const conditions = [drizzleOrm.sql`${table}."graph_id" = ${params.graphId}`];
     if (params.minScore !== void 0) {
       conditions.push(
-        chunkCFNT3ITG_cjs.vectorMinScoreCondition(distance, params.metric, params.minScore)
+        chunk2JXB3NYJ_cjs.vectorMinScoreCondition(distance, params.metric, params.minScore)
       );
     }
     return drizzleOrm.sql`
@@ -188,17 +189,17 @@ var pgvectorStrategy = {
   buildDropIndex(slot) {
     if (!usesAnnIndex(slot)) return void 0;
     const indexName = pgvectorIndexName(slot);
-    return drizzleOrm.sql.raw(`DROP INDEX IF EXISTS ${chunkCFNT3ITG_cjs.quoteIdentifier(indexName)}`);
+    return drizzleOrm.sql.raw(`DROP INDEX IF EXISTS ${chunk2JXB3NYJ_cjs.quoteIdentifier(indexName)}`);
   },
   buildDropStorage(slot) {
-    const table = chunkCFNT3ITG_cjs.quoteIdentifier(
+    const table = chunk2JXB3NYJ_cjs.quoteIdentifier(
       this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath)
     );
     return [`DROP TABLE IF EXISTS ${table} CASCADE`];
   }
 };
 function pgvectorIndexName(slot) {
-  return chunkCFNT3ITG_cjs.vectorPhysicalName(
+  return chunk2JXB3NYJ_cjs.vectorPhysicalName(
     INDEX_PREFIX,
     slot.graphId,
     slot.nodeKind,
@@ -206,8 +207,8 @@ function pgvectorIndexName(slot) {
   );
 }
 function pgvectorIndexDdl(table, slot, concurrent) {
-  const indexName = chunkCFNT3ITG_cjs.quoteIdentifier(pgvectorIndexName(slot));
-  const quotedTable = chunkCFNT3ITG_cjs.quoteIdentifier(table);
+  const indexName = chunk2JXB3NYJ_cjs.quoteIdentifier(pgvectorIndexName(slot));
+  const quotedTable = chunk2JXB3NYJ_cjs.quoteIdentifier(table);
   const opClass = operatorClass(slot.metric);
   const m = slot.indexParams?.m ?? DEFAULT_HNSW_M;
   const efConstruction = slot.indexParams?.efConstruction ?? DEFAULT_HNSW_EF_CONSTRUCTION;
@@ -234,5 +235,5 @@ function pgvectorIndexDdl(table, slot, concurrent) {
 
 exports.assertPgvectorEfSearch = assertPgvectorEfSearch;
 exports.pgvectorStrategy = pgvectorStrategy;
-//# sourceMappingURL=chunk-YW7GHMF4.cjs.map
-//# sourceMappingURL=chunk-YW7GHMF4.cjs.map
+//# sourceMappingURL=chunk-KGC4LY5T.cjs.map
+//# sourceMappingURL=chunk-KGC4LY5T.cjs.map

package/dist/chunk-KGC4LY5T.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/drizzle/columns/vector.ts","../src/query/dialect/vector/pgvector-strategy.ts"],"names":["customType","assertFiniteEmbedding","sql","vectorPhysicalName","quoteIdentifier","VECTOR_CONTRIBUTION_PREFIX","quotedTableName","vectorScoreExpression","vectorMinScoreCondition"],"mappings":";;;;;;;AA0CsBA,iBAAA,CAInB;AAAA,EACD,SAAS,MAAA,EAAQ;AAEf,IAAA,OAAO,MAAA,EAAQ,UAAA,GAAa,CAAA,OAAA,EAAU,MAAA,CAAO,UAAU,CAAA,CAAA,CAAA,GAAM,QAAA;AAAA,EAC/D,CAAA;AAAA,EAEA,SAAS,KAAA,EAAyB;AAEhC,IAAA,OAAO,CAAA,CAAA,EAAI,KAAA,CAAM,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA;AAAA,EAC5B,CAAA;AAAA,EAEA,WAAW,KAAA,EAAyB;AAGlC,IAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxB,MAAA,OAAO,KAAA;AAAA,IACT;AAEA,IAAA,MAAM,OAAA,GAAU,KAAA,CAAM,KAAA,CAAM,CAAA,EAAG,EAAE,CAAA;AACjC,IAAA,IAAI,YAAY,EAAA,EAAI;AAClB,MAAA,OAAO,EAAC;AAAA,IACV;AACA,IAAA,OAAO,OAAA,CAAQ,KAAA,CAAM,GAAG,CAAA,CAAE,GAAA,CAAI,CAAC,CAAA,KAAM,MAAA,CAAO,UAAA,CAAW,CAAA,CAAE,IAAA,EAAM,CAAC,CAAA;AAAA,EAClE;AACF,CAAC;AAgBM,SAAS,aAAa,SAAA,EAAsC;AACjE,EAAA,OAAO,CAAA,CAAA,EAAI,SAAA,CAAU,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA;AAChC;;;ACzCA,IAAM,YAAA,GAAe,QAAA;AACrB,IAAM,YAAA,GAAe,WAAA;AASd,IAAM,kBAAA,GAAqB,GAAA;AAM3B,SAAS,uBAAuB,QAAA,EAAyB;AAC9D,EAAA,IAAI,aAAa,MAAA,EAAW;AAC5B,EAAA,IAAI,CAAC,MAAA,CAAO,SAAA,CAAU,QAAQ,CAAA,IAAK,YAAY,CAAA,EAAG;AAChD,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,0CAAA,EAA6C,QAAQ,CAAA,CAAE,CAAA;AAAA,EACzE;AACA,EAAA,IAAI,WAAW,kBAAA,EAAoB;AACjC,IAAA,MAAM,IAAI,UAAA;AAAA,MACR,CAAA,wBAAA,EAAsB,kBAAkB,CAAA,8CAAA,EACjB,kBAAkB,WAAW,QAAQ,CAAA;AAAA,KAC9D;AAAA,EACF;AACF;AAQA,IAAM,uBAAA,GAA0B,IAAA;AAGhC,IAAM,cAAA,GAAiB,EAAA;AAEvB,IAAM,4BAAA,GAA+B,EAAA;AAErC,IAAM,qBAAA,GAAwB,GAAA;AAE9B,IAAM,qBAAA,GAA4C;AAAA,EAChD,SAAA,EAAW,IAAA;AAAA,EACX,OAAA,EAAS,CAAC,QAAA,EAAU,IAAA,EAAM,eAAe,CAAA;AAAA,EACzC,UAAA,EAAY,CAAC,MAAA,EAAQ,SAAA,EAAW,MAAM,CAAA;AAAA,EACtC,aAAA,EAAe;AACjB,CAAA;AAGA,SAAS,aAAa,IAAA,EAA2B;AAC/C,EAAA,OAAO,IAAA,CAAK,SAAA,KAAc,MAAA,IAAU,IAAA,CAAK,SAAA,KAAc,SAAA;AACzD;AAOA,SAAS,cAAc,MAAA,EAA8B;AACnD,EAAA,QAAQ,MAAA;AAAQ,IACd,KAAK,QAAA,EAAU;AACb,MAAA,OAAO,mBAAA;AAAA,IACT;AAAA,IACA,KAAK,IAAA,EAAM;AACT,MAAA,OAAO,eAAA;AAAA,IACT;AAAA,IACA,KAAK,eAAA,EAAiB;AACpB,MAAA,OAAO,eAAA;AAAA,IACT;AAAA,IACA,SAAS;AACP,MAAA,MAAM,WAAA,GAAqB,MAAA;AAC3B,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,2BAAA,EAA8B,MAAA,CAAO,WAAW,CAAC,CAAA,CAAE,CAAA;AAAA,IACrE;AAAA;AAEJ;AAOA,SAAS,aAAA,CAAc,WAA8B,IAAA,EAAmB;AACtE,EAAAC,uCAAA,CAAsB,WAAW,IAAI,CAAA;AACrC,EAAA,OAAOC,cAAA,CAAA,EAAM,YAAA,CAAa,SAAS,CAAC,CAAA,QAAA,CAAA;AACtC;AAEA,SAAS,kBAAA,CACP,eAAA,EACA,cAAA,EACA,MAAA,EACK;AACL,EAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,cAAA,EAAgB,gBAAgB,CAAA;AAC5D,EAAA,QAAQ,MAAA;AAAQ,IACd,KAAK,QAAA,EAAU;AACb,MAAA,OAAOA,cAAA,CAAA,CAAA,EAAO,eAAe,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA,CAAA;AAAA,IAC5C;AAAA,IACA,KAAK,IAAA,EAAM;AACT,MAAA,OAAOA,cAAA,CAAA,CAAA,EAAO,eAAe,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA,CAAA;AAAA,IAC5C;AAAA,IACA,KAAK,eAAA,EAAiB;AACpB,MAAA,OAAOA,cAAA,CAAA,CAAA,EAAO,eAAe,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA,CAAA;AAAA,IAC5C;AAAA,IACA,SAAS;AACP,MAAA,MAAM,WAAA,GAAqB,MAAA;AAC3B,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,2BAAA,EAA8B,MAAA,CAAO,WAAW,CAAC,CAAA,CAAE,CAAA;AAAA,IACrE;AAAA;AAEJ;AAEO,IAAM,gBAAA,GAAmC;AAAA,EAC9C,IAAA,EAAM,UAAA;AAAA,EACN,YAAA,EAAc,qBAAA;AAAA,EAEd,SAAA,CAAU,OAAA,EAAS,QAAA,EAAU,SAAA,EAAW;AACtC,IAAA,OAAOC,oCAAA,CAAmB,YAAA,EAAc,OAAA,EAAS,QAAA,EAAU,SAAS,CAAA;AAAA,EACtE,CAAA;AAAA,EAEA,YAAY,IAAA,EAA4C;AACtD,IAAA,MAAM,KAAA,GAAQ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS,CAAA;AACxE,IAAA,MAAM,IAAA,GAAOC,kCAAgB,KAAK,CAAA;AAKlC,IAAA,MAAM,SAAA,GAAY;AAAA,MAChB,8BAA8B,IAAI,CAAA;AAAA;AAAA;AAAA,qBAAA,EAGjB,KAAK,UAAU,CAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AAAA,KAKlC;AAWA,IAAA,OAAO;AAAA,MACL;AAAA,QACE,WAAA,EAAa,GAAGC,4CAA0B,CAAA,CAAA,EAAI,KAAK,QAAQ,CAAA,CAAA,EAAI,KAAK,SAAS,CAAA,CAAA;AAAA,QAC7E,KAAA,EAAO,UAAA;AAAA,QACP,SAAA,EAAW,KAAA;AAAA,QACX,SAAA;AAAA,QACA,aAAA,EAAe;AAAA;AACjB,KACF;AAAA,EACF,CAAA;AAAA,EAEA,WAAA,CAAY,IAAA,EAAM,MAAA,EAA+B,SAAA,EAA2B;AAC1E,IAAA,MAAM,KAAA,GAAQC,iCAAA;AAAA,MACZ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS;AAAA,KAC5D;AACA,IAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,MAAA,CAAO,SAAA,EAAW,WAAW,CAAA;AACzD,IAAA,OAAO;AAAA,MACLJ,cAAA;AAAA,oBAAA,EACgB,KAAK,CAAA;AAAA,gBAAA,EACT,MAAA,CAAO,OAAO,CAAA,EAAA,EAAK,MAAA,CAAO,MAAM,KAAK,KAAK,CAAA,EAAA,EAAK,SAAS,CAAA,EAAA,EAAK,SAAS,CAAA;AAAA;AAAA;AAAA,MAAA;AAAA,KAIpF;AAAA,EACF,CAAA;AAAA,EAEA,WAAA,CAAY,MAAM,MAAA,EAA+C;AAC/D,IAAA,MAAM,KAAA,GAAQI,iCAAA;AAAA,MACZ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS;AAAA,KAC5D;AACA,IAAA,OAAO;AAAA,MACLJ,cAAA;AAAA,oBAAA,EACgB,KAAK;AAAA,2BAAA,EACE,MAAA,CAAO,OAAO,CAAA,iBAAA,EAAoB,MAAA,CAAO,MAAM;AAAA,MAAA;AAAA,KAExE;AAAA,EACF,CAAA;AAAA,EAEA,WAAA,CAAY,MAAM,MAAA,EAAiC;AACjD,IAAA,MAAM,KAAA,GAAQI,iCAAA;AAAA,MACZ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS;AAAA,KAC5D;AACA,IAAA,MAAM,eAAA,GAAkBJ,iBAAM,KAAK,CAAA,YAAA,CAAA;AACnC,IAAA,MAAM,QAAA,GAAW,kBAAA;AAAA,MACf,eAAA;AAAA,MACA,MAAA,CAAO,cAAA;AAAA,MACP,MAAA,CAAO;AAAA,KACT;AACA,IAAA,MAAM,KAAA,GAAQK,uCAAA,CAAsB,QAAA,EAAU,MAAA,CAAO,MAAM,CAAA;AAK3D,IAAA,MAAM,aAAoB,CAACL,cAAA,CAAA,EAAM,KAAK,CAAA,cAAA,EAAiB,MAAA,CAAO,OAAO,CAAA,CAAE,CAAA;AACvE,IAAA,IAAI,MAAA,CAAO,aAAa,MAAA,EAAW;AACjC,MAAA,UAAA,CAAW,IAAA;AAAA,QACTM,yCAAA,CAAwB,QAAA,EAAU,MAAA,CAAO,MAAA,EAAQ,OAAO,QAAQ;AAAA,OAClE;AAAA,IACF;AACA,IAAA,OAAON,cAAA;AAAA,aAAA,EACI,KAAK,0BAA0B,KAAK,CAAA;AAAA,WAAA,EACtC,KAAK;AAAA,YAAA,EACJA,cAAA,CAAI,IAAA,CAAK,UAAA,EAAYA,cAAA,CAAA,KAAA,CAAU,CAAC;AAAA,eAAA,EAC7B,QAAQ,CAAA;AAAA,YAAA,EACX,OAAO,KAAK;AAAA,IAAA,CAAA;AAAA,EAExB,CAAA;AAAA,EAEA,kBAAA,CAAmB,eAAA,EAAiB,cAAA,EAAgB,MAAA,EAAQ;AAC1D,IAAA,OAAO,kBAAA,CAAmB,eAAA,EAAiB,cAAA,EAAgB,MAAM,CAAA;AAAA,EACnE,CAAA;AAAA,EAEA,gBAAA,CAAiB,MAAM,OAAA,EAA0B;AAC/C,IAAA,IAAI,CAAC,YAAA,CAAa,IAAI,CAAA,EAAG,OAAO,MAAA;AAChC,IAAA,OAAOA,cAAA,CAAI,GAAA;AAAA,MACT,gBAAA;AAAA,QACE,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS,CAAA;AAAA,QAC1D,IAAA;AAAA,QACA,SAAS,UAAA,KAAe;AAAA;AAC1B,KACF;AAAA,EACF,CAAA;AAAA,EAEA,eAAe,IAAA,EAAuB;AACpC,IAAA,IAAI,CAAC,YAAA,CAAa,IAAI,CAAA,EAAG,OAAO,MAAA;AAChC,IAAA,MAAM,SAAA,GAAY,kBAAkB,IAAI,CAAA;AACxC,IAAA,OAAOA,eAAI,GAAA,CAAI,CAAA,qBAAA,EAAwBE,iCAAA,CAAgB,SAAS,CAAC,CAAA,CAAE,CAAA;AAAA,EACrE,CAAA;AAAA,EAEA,iBAAiB,IAAA,EAAyB;AACxC,IAAA,MAAM,KAAA,GAAQA,iCAAA;AAAA,MACZ,KAAK,SAAA,CAAU,IAAA,CAAK,SAAS,IAAA,CAAK,QAAA,EAAU,KAAK,SAAS;AAAA,KAC5D;AAEA,IAAA,OAAO,CAAC,CAAA,qBAAA,EAAwB,KAAK,CAAA,QAAA,CAAU,CAAA;AAAA,EACjD;AACF;AAEA,SAAS,kBAAkB,IAAA,EAA0B;AACnD,EAAA,OAAOD,oCAAA;AAAA,IACL,YAAA;AAAA,IACA,IAAA,CAAK,OAAA;AAAA,IACL,IAAA,CAAK,QAAA;AAAA,IACL,IAAA,CAAK;AAAA,GACP;AACF;AAEA,SAAS,gBAAA,CACP,KAAA,EACA,IAAA,EACA,UAAA,EACQ;AACR,EAAA,MAAM,SAAA,GAAYC,iCAAA,CAAgB,iBAAA,CAAkB,IAAI,CAAC,CAAA;AACzD,EAAA,MAAM,WAAA,GAAcA,kCAAgB,KAAK,CAAA;AACzC,EAAA,MAAM,OAAA,GAAU,aAAA,CAAc,IAAA,CAAK,MAAM,CAAA;AAEzC,EAAA,MAAM,CAAA,GAAI,IAAA,CAAK,WAAA,EAAa,CAAA,IAAK,cAAA;AACjC,EAAA,MAAM,cAAA,GACJ,IAAA,CAAK,WAAA,EAAa,cAAA,IAAkB,4BAAA;AACtC,EAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,WAAA,EAAa,KAAA,IAAS,qBAAA;AAGzC,EAAA,MAAM,MAAA,GAAS,CAAA,YAAA,EAAe,UAAA,GAAa,eAAA,GAAkB,EAAE,CAAA,cAAA,CAAA;AAE/D,EAAA,QAAQ,KAAK,SAAA;AAAW,IACtB,KAAK,MAAA,EAAQ;AACX,MAAA,OAAO,CAAA,EAAG,MAAM,CAAA,CAAA,EAAI,SAAS,CAAA,IAAA,EAAO,WAAW,CAAA,yBAAA,EAA4B,OAAO,CAAA,YAAA,EAAe,CAAC,CAAA,oBAAA,EAAuB,cAAc,CAAA,EAAA,CAAA;AAAA,IACzI;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,OAAO,CAAA,EAAG,MAAM,CAAA,CAAA,EAAI,SAAS,OAAO,WAAW,CAAA,4BAAA,EAA+B,OAAO,CAAA,gBAAA,EAAmB,KAAK,CAAA,EAAA,CAAA;AAAA,IAC/G;AAAA,IACA,KAAK,MAAA,EAAQ;AACX,MAAA,MAAM,IAAI,KAAA;AAAA,QACR;AAAA,OACF;AAAA,IACF;AAAA,IACA,SAAS;AACP,MAAA,MAAM,cAAqB,IAAA,CAAK,SAAA;AAChC,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,+BAAA,EAAkC,MAAA,CAAO,WAAW,CAAC,CAAA,CAAE,CAAA;AAAA,IACzE;AAAA;AAEJ","file":"chunk-KGC4LY5T.cjs","sourcesContent":["/**\n * Custom Drizzle column type for pgvector's VECTOR type.\n *\n * Provides native support for PostgreSQL vector embeddings without\n * requiring runtime casts in queries.\n *\n * @example\n * ```typescript\n * import { pgTable, text, integer } from \"drizzle-orm/pg-core\";\n * import { vector } from \"./columns/vector\";\n *\n * const embeddings = pgTable(\"embeddings\", {\n *   id: text(\"id\").primaryKey(),\n *   embedding: vector(\"embedding\"),\n *   dimensions: integer(\"dimensions\"),\n * });\n * ```\n */\nimport { customType } from \"drizzle-orm/pg-core\";\n\n/**\n * PostgreSQL vector column type for pgvector extension.\n *\n * Stores embeddings as native VECTOR type, enabling efficient\n * similarity search without runtime casts.\n *\n * The column type is unparameterized (`VECTOR` not `VECTOR(N)`)\n * to support multiple embedding dimensions in a single table.\n * Dimension validation is handled at the application level.\n *\n * @example\n * ```typescript\n * // In table definition\n * embedding: vector(\"embedding\").notNull(),\n *\n * // In queries - no cast needed\n * db.execute(sql`\n *   SELECT * FROM embeddings\n *   WHERE embedding <=> ${formatVector([0.1, 0.2, 0.3])} < 0.5\n * `);\n * ```\n */\nexport const vector = customType<{\n  data: number[];\n  driverData: string;\n  config: { dimensions?: number };\n}>({\n  dataType(config) {\n    // Use parameterized type if dimensions specified, otherwise unparameterized\n    return config?.dimensions ? `vector(${config.dimensions})` : \"vector\";\n  },\n\n  toDriver(value: number[]): string {\n    // Format as pgvector literal: [1.0,2.0,3.0]\n    return `[${value.join(\",\")}]`;\n  },\n\n  fromDriver(value: string): number[] {\n    // pgvector returns '[1,2,3]' format\n    // Handle both string and already-parsed array (some drivers differ)\n    if (Array.isArray(value)) {\n      return value as number[];\n    }\n    // Parse the string representation\n    const content = value.slice(1, -1); // Remove [ and ]\n    if (content === \"\") {\n      return [];\n    }\n    return content.split(\",\").map((s) => Number.parseFloat(s.trim()));\n  },\n});\n\n/**\n * Formats a number array as a pgvector literal string.\n *\n * Use this when building raw SQL queries with embeddings.\n *\n * @example\n * ```typescript\n * const embedding = [0.1, 0.2, 0.3];\n * db.execute(sql`\n *   SELECT * FROM embeddings\n *   WHERE embedding <=> ${formatVector(embedding)}::vector < 0.5\n * `);\n * ```\n */\nexport function formatVector(embedding: readonly number[]): string {\n  return `[${embedding.join(\",\")}]`;\n}\n","/**\n * pgvector strategy.\n *\n * Postgres' pgvector extension is the one engine where the *same* SQL serves\n * brute-force and ANN: `ORDER BY embedding <=> q LIMIT k` scans sequentially\n * with no index and is rewritten to an HNSW/IVFFlat scan the moment a matching\n * index exists — the planner picks it up automatically. So `buildSearch` never\n * branches on `slot.indexType`; it emits one relevance scan and lets Postgres\n * decide. (Contrast libSQL/sqlite-vec, whose ANN needs distinct syntax.)\n *\n * Storage is per-`(nodeKind, fieldPath)`: a `vector(N)` column carrying the\n * field's fixed dimension `N`, with the operator-class-typed ANN index folded\n * into the same table contribution so materialization builds table + index\n * together. The typed column means the index does not need the legacy\n * `::vector(N)` cast-in-index escape hatch the old shared table relied on.\n *\n * Metric support is the full pgvector set — `cosine`, `l2`, `inner_product` —\n * advertised as data on `capabilities`, mirroring `vector_cosine_ops` /\n * `vector_l2_ops` / `vector_ip_ops` and the `<=>` / `<->` / `<#>` operators.\n *\n * Mirrors the `libsqlVectorStrategy` / `sqliteVecStrategy` structure while\n * letting Postgres' planner pick the ANN index when one exists.\n */\nimport { type SQL, sql } from \"drizzle-orm\";\n\nimport { formatVector } from \"../../../backend/drizzle/columns/vector\";\nimport { quotedTableName } from \"../../../backend/drizzle/operations/shared\";\nimport { type StrategyTableContribution } from \"../../../backend/table-contribution\";\nimport {\n  type DeleteEmbeddingParams,\n  type UpsertEmbeddingParams,\n  type VectorCapabilities,\n  type VectorMetric,\n  type VectorSearchParams,\n} from \"../../../backend/types\";\nimport {\n  assertFiniteEmbedding,\n  quoteIdentifier,\n  VECTOR_CONTRIBUTION_PREFIX,\n  vectorMinScoreCondition,\n  vectorPhysicalName,\n  vectorScoreExpression,\n  type VectorSlot,\n  type VectorStrategy,\n} from \"../vector-strategy\";\n\n/** Physical-name prefixes for the per-field table and its ANN index. */\nconst TABLE_PREFIX = \"tg_vec\";\nconst INDEX_PREFIX = \"tg_vecidx\";\n\n/**\n * pgvector defines `hnsw.ef_search` as an integer GUC with a valid range\n * of 1..1000; `SET hnsw.ef_search = 1001` errors at the server. The\n * backend validates a per-search `efSearch` against this ceiling before\n * inlining it into `SET LOCAL`, surfacing a clear message instead of a raw\n * pgvector error.\n */\nexport const MAX_HNSW_EF_SEARCH = 1000;\n\n/**\n * Validates a per-search `efSearch` override against pgvector's\n * `hnsw.ef_search` valid range. `undefined` (no override) is accepted.\n */\nexport function assertPgvectorEfSearch(efSearch?: number): void {\n  if (efSearch === undefined) return;\n  if (!Number.isInteger(efSearch) || efSearch <= 0) {\n    throw new Error(`efSearch must be a positive integer, got: ${efSearch}`);\n  }\n  if (efSearch > MAX_HNSW_EF_SEARCH) {\n    throw new RangeError(\n      `efSearch must be ≤ ${MAX_HNSW_EF_SEARCH} (pgvector's hnsw.ef_search ` +\n        `valid range is 1..${MAX_HNSW_EF_SEARCH}), got: ${efSearch}`,\n    );\n  }\n}\n\n/**\n * pgvector's `vector` type caps at 16,000 dimensions for a stored column\n * (2,000 for an indexed column, but the column-type ceiling is what governs\n * storage; recall degradation beyond 2,000 is a tuning concern, not a hard\n * limit advertised here).\n */\nconst PGVECTOR_MAX_DIMENSIONS = 16_000;\n\n/** Default HNSW `m` (max connections per layer) — pgvector's own default. */\nconst DEFAULT_HNSW_M = 16;\n/** Default HNSW `ef_construction` (build candidate list) — pgvector's own default. */\nconst DEFAULT_HNSW_EF_CONSTRUCTION = 64;\n/** Default IVFFlat `lists` (inverted lists) — pgvector's own default. */\nconst DEFAULT_IVFFLAT_LISTS = 100;\n\nconst PGVECTOR_CAPABILITIES: VectorCapabilities = {\n  supported: true,\n  metrics: [\"cosine\", \"l2\", \"inner_product\"],\n  indexTypes: [\"hnsw\", \"ivfflat\", \"none\"],\n  maxDimensions: PGVECTOR_MAX_DIMENSIONS,\n};\n\n/** Whether a slot's declared index type materializes a real pgvector ANN index. */\nfunction usesAnnIndex(slot: VectorSlot): boolean {\n  return slot.indexType === \"hnsw\" || slot.indexType === \"ivfflat\";\n}\n\n/**\n * pgvector operator class for a metric's ANN index — `vector_cosine_ops` /\n * `vector_l2_ops` / `vector_ip_ops`, mirroring the `<=>` / `<->` / `<#>`\n * distance operators this strategy emits.\n */\nfunction operatorClass(metric: VectorMetric): string {\n  switch (metric) {\n    case \"cosine\": {\n      return \"vector_cosine_ops\";\n    }\n    case \"l2\": {\n      return \"vector_l2_ops\";\n    }\n    case \"inner_product\": {\n      return \"vector_ip_ops\";\n    }\n    default: {\n      const _exhaustive: never = metric;\n      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);\n    }\n  }\n}\n\n/**\n * Formats an embedding as a `::vector` literal. The value is bound as a\n * parameter (not interpolated) — Postgres parses the `[a,b,c]` text and the\n * cast types it. Finiteness is validated first so a NaN names its index.\n */\nfunction vectorLiteral(embedding: readonly number[], name: string): SQL {\n  assertFiniteEmbedding(embedding, name);\n  return sql`${formatVector(embedding)}::vector`;\n}\n\nfunction distanceExpression(\n  embeddingColumn: SQL,\n  queryEmbedding: readonly number[],\n  metric: VectorMetric,\n): SQL {\n  const query = vectorLiteral(queryEmbedding, \"queryEmbedding\");\n  switch (metric) {\n    case \"cosine\": {\n      return sql`(${embeddingColumn} <=> ${query})`;\n    }\n    case \"l2\": {\n      return sql`(${embeddingColumn} <-> ${query})`;\n    }\n    case \"inner_product\": {\n      return sql`(${embeddingColumn} <#> ${query})`;\n    }\n    default: {\n      const _exhaustive: never = metric;\n      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);\n    }\n  }\n}\n\nexport const pgvectorStrategy: VectorStrategy = {\n  name: \"pgvector\",\n  capabilities: PGVECTOR_CAPABILITIES,\n\n  tableName(graphId, nodeKind, fieldPath) {\n    return vectorPhysicalName(TABLE_PREFIX, graphId, nodeKind, fieldPath);\n  },\n\n  ownedTables(slot): readonly StrategyTableContribution[] {\n    const table = this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath);\n    const name = quoteIdentifier(table);\n\n    // No standalone graph_id index: the PRIMARY KEY (graph_id, node_id) already\n    // covers `WHERE graph_id = ?` via its leading column, so a separate index\n    // would be pure write amplification.\n    const createDdl = [\n      `CREATE TABLE IF NOT EXISTS ${name} (\n  \"graph_id\" TEXT NOT NULL,\n  \"node_id\" TEXT NOT NULL,\n  \"embedding\" vector(${slot.dimensions}) NOT NULL,\n  \"created_at\" TIMESTAMPTZ NOT NULL,\n  \"updated_at\" TIMESTAMPTZ NOT NULL,\n  PRIMARY KEY (\"graph_id\", \"node_id\")\n);`,\n    ];\n\n    // The HNSW/IVFFlat index is intentionally NOT created here. pgvector\n    // similarity SQL is planner-driven (`ORDER BY embedding <=> q LIMIT k`\n    // uses the index when present, sequential-scans when not), so the index\n    // is a pure materialization concern: `buildCreateIndex` builds it through\n    // `materializeIndexes()` with the field's declared `m`/`ef_construction`/\n    // `lists`. Building it eagerly here would bake in default tuning (the\n    // write-ensure slot has no `indexParams`) and `CREATE INDEX IF NOT EXISTS`\n    // would then mask the tuned index materialization would emit.\n\n    return [\n      {\n        logicalName: `${VECTOR_CONTRIBUTION_PREFIX}:${slot.nodeKind}.${slot.fieldPath}`,\n        owner: \"pgvector\",\n        tableName: table,\n        createDdl,\n        runtimeEnsure: true,\n      },\n    ];\n  },\n\n  buildUpsert(slot, params: UpsertEmbeddingParams, timestamp): readonly SQL[] {\n    const table = quotedTableName(\n      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n    );\n    const value = vectorLiteral(params.embedding, \"embedding\");\n    return [\n      sql`\n        INSERT INTO ${table} (\"graph_id\", \"node_id\", \"embedding\", \"created_at\", \"updated_at\")\n        VALUES (${params.graphId}, ${params.nodeId}, ${value}, ${timestamp}, ${timestamp})\n        ON CONFLICT (\"graph_id\", \"node_id\")\n        DO UPDATE SET \"embedding\" = EXCLUDED.\"embedding\", \"updated_at\" = EXCLUDED.\"updated_at\"\n      `,\n    ];\n  },\n\n  buildDelete(slot, params: DeleteEmbeddingParams): readonly SQL[] {\n    const table = quotedTableName(\n      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n    );\n    return [\n      sql`\n        DELETE FROM ${table}\n        WHERE \"graph_id\" = ${params.graphId} AND \"node_id\" = ${params.nodeId}\n      `,\n    ];\n  },\n\n  buildSearch(slot, params: VectorSearchParams): SQL {\n    const table = quotedTableName(\n      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n    );\n    const embeddingColumn = sql`${table}.\"embedding\"`;\n    const distance = distanceExpression(\n      embeddingColumn,\n      params.queryEmbedding,\n      params.metric,\n    );\n    const score = vectorScoreExpression(distance, params.metric);\n\n    // Same SQL for brute-force and ANN: with a matching HNSW/IVFFlat index the\n    // Postgres planner rewrites this `ORDER BY distance LIMIT k` into an index\n    // scan automatically, so the strategy never branches on `slot.indexType`.\n    const conditions: SQL[] = [sql`${table}.\"graph_id\" = ${params.graphId}`];\n    if (params.minScore !== undefined) {\n      conditions.push(\n        vectorMinScoreCondition(distance, params.metric, params.minScore),\n      );\n    }\n    return sql`\n      SELECT ${table}.\"node_id\" AS node_id, ${score} AS score\n      FROM ${table}\n      WHERE ${sql.join(conditions, sql` AND `)}\n      ORDER BY ${distance} ASC\n      LIMIT ${params.limit}\n    `;\n  },\n\n  distanceExpression(embeddingColumn, queryEmbedding, metric) {\n    return distanceExpression(embeddingColumn, queryEmbedding, metric);\n  },\n\n  buildCreateIndex(slot, options): SQL | undefined {\n    if (!usesAnnIndex(slot)) return undefined;\n    return sql.raw(\n      pgvectorIndexDdl(\n        this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n        slot,\n        options?.concurrent === true,\n      ),\n    );\n  },\n\n  buildDropIndex(slot): SQL | undefined {\n    if (!usesAnnIndex(slot)) return undefined;\n    const indexName = pgvectorIndexName(slot);\n    return sql.raw(`DROP INDEX IF EXISTS ${quoteIdentifier(indexName)}`);\n  },\n\n  buildDropStorage(slot): readonly string[] {\n    const table = quoteIdentifier(\n      this.tableName(slot.graphId, slot.nodeKind, slot.fieldPath),\n    );\n    // CASCADE drops the ANN index along with the table.\n    return [`DROP TABLE IF EXISTS ${table} CASCADE`];\n  },\n};\n\nfunction pgvectorIndexName(slot: VectorSlot): string {\n  return vectorPhysicalName(\n    INDEX_PREFIX,\n    slot.graphId,\n    slot.nodeKind,\n    slot.fieldPath,\n  );\n}\n\nfunction pgvectorIndexDdl(\n  table: string,\n  slot: VectorSlot,\n  concurrent: boolean,\n): string {\n  const indexName = quoteIdentifier(pgvectorIndexName(slot));\n  const quotedTable = quoteIdentifier(table);\n  const opClass = operatorClass(slot.metric);\n  // Honor the field's declared tuning; fall back to pgvector defaults.\n  const m = slot.indexParams?.m ?? DEFAULT_HNSW_M;\n  const efConstruction =\n    slot.indexParams?.efConstruction ?? DEFAULT_HNSW_EF_CONSTRUCTION;\n  const lists = slot.indexParams?.lists ?? DEFAULT_IVFFLAT_LISTS;\n  // CONCURRENTLY builds without taking a write-blocking lock on the live table\n  // (materializeIndexes passes concurrent on Postgres). Run outside a tx.\n  const create = `CREATE INDEX${concurrent ? \" CONCURRENTLY\" : \"\"} IF NOT EXISTS`;\n\n  switch (slot.indexType) {\n    case \"hnsw\": {\n      return `${create} ${indexName} ON ${quotedTable} USING hnsw (\"embedding\" ${opClass}) WITH (m = ${m}, ef_construction = ${efConstruction});`;\n    }\n    case \"ivfflat\": {\n      return `${create} ${indexName} ON ${quotedTable} USING ivfflat (\"embedding\" ${opClass}) WITH (lists = ${lists});`;\n    }\n    case \"none\": {\n      throw new Error(\n        \"pgvectorIndexDdl called for a brute-force-only slot (indexType 'none').\",\n      );\n    }\n    default: {\n      const _exhaustive: never = slot.indexType;\n      throw new Error(`Unsupported vector index type: ${String(_exhaustive)}`);\n    }\n  }\n}\n"]}

package/dist/{chunk-SB65GJNY.cjs → chunk-KNHYNQQ3.cjs}

@@ -1,10 +1,15 @@
 'use strict';
 
-var chunkEEYV6UOE_cjs = require('./chunk-EEYV6UOE.cjs');
+var chunkN6WTUSBV_cjs = require('./chunk-N6WTUSBV.cjs');
+var chunkT6SPUYLX_cjs = require('./chunk-T6SPUYLX.cjs');
+var chunk5IQIX7LU_cjs = require('./chunk-5IQIX7LU.cjs');
+var chunkUNNPKQUG_cjs = require('./chunk-UNNPKQUG.cjs');
+var chunkYC6PWTHY_cjs = require('./chunk-YC6PWTHY.cjs');
+var chunkJIEJCTDS_cjs = require('./chunk-JIEJCTDS.cjs');
 var zod = require('zod');
 
 var FORMAT_VERSION = "1.0";
-var ValidityTimestampSchema = zod.z.iso.datetime().refine((value) => chunkEEYV6UOE_cjs.isCanonicalIsoDate(value), {
+var ValidityTimestampSchema = zod.z.iso.datetime().refine((value) => chunkYC6PWTHY_cjs.isCanonicalIsoDate(value), {
   message: "Expected canonical UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ); convert with new Date(value).toISOString()."
 });
 var InterchangeNodeSchema = zod.z.object({
@@ -117,8 +122,8 @@ async function exportGraph(store, options) {
   const graph = store.graph;
   const graphId = store.graphId;
   const backend = store.backend;
-  const nodeKindsToExport = options_.nodeKinds ?? chunkEEYV6UOE_cjs.getNodeKinds(graph);
-  const edgeKindsToExport = options_.edgeKinds ?? chunkEEYV6UOE_cjs.getEdgeKinds(graph);
+  const nodeKindsToExport = options_.nodeKinds ?? chunkT6SPUYLX_cjs.getNodeKinds(graph);
+  const edgeKindsToExport = options_.edgeKinds ?? chunkT6SPUYLX_cjs.getEdgeKinds(graph);
   const nodes = [];
   for (const kind of nodeKindsToExport) {
     const kindNodes = await exportNodesOfKind(backend, graphId, kind, options_);
@@ -132,7 +137,7 @@ async function exportGraph(store, options) {
   const schemaVersion = await backend.getActiveSchema(graphId);
   return {
     formatVersion: FORMAT_VERSION,
-    exportedAt: chunkEEYV6UOE_cjs.nowIso(),
+    exportedAt: chunkYC6PWTHY_cjs.nowIso(),
     source: {
       type: "typegraph-export",
       graphId,
@@ -222,47 +227,27 @@ async function importGraph(store, data, options) {
   const graph = store.graph;
   const graphId = store.graphId;
   const backend = store.backend;
+  const registry = store.registry;
   const nodeSchemas = buildNodeSchemaMap(graph);
   const edgeSchemas = buildEdgeSchemaMap(graph);
   const importedNodeIds = /* @__PURE__ */ new Set();
-  if (backend.capabilities.transactions) {
-    await backend.transaction(async (tx) => {
-      await processNodes(
-        tx,
-        graphId,
-        data.nodes,
-        nodeSchemas,
-        options,
-        result,
-        errors,
-        importedNodeIds
-      );
-      await processEdges(
-        tx,
-        graphId,
-        data.edges,
-        edgeSchemas,
-        nodeSchemas,
-        options,
-        result,
-        errors,
-        importedNodeIds
-      );
-    });
-  } else {
+  await chunkN6WTUSBV_cjs.runInWriteTransaction(store, backend, async (target, lock) => {
     await processNodes(
-      backend,
+      target,
       graphId,
+      registry,
       data.nodes,
       nodeSchemas,
       options,
       result,
       errors,
-      importedNodeIds
+      importedNodeIds,
+      lock
     );
     await processEdges(
-      backend,
+      target,
       graphId,
+      registry,
       data.edges,
       edgeSchemas,
       nodeSchemas,
@@ -271,7 +256,7 @@ async function importGraph(store, data, options) {
       errors,
       importedNodeIds
     );
-  }
+  });
   return {
     ...result,
     success: errors.length === 0,
@@ -280,7 +265,7 @@ async function importGraph(store, data, options) {
 }
 function buildNodeSchemaMap(graph) {
   const map = /* @__PURE__ */ new Map();
-  for (const kindName of chunkEEYV6UOE_cjs.getNodeKinds(graph)) {
+  for (const kindName of chunkT6SPUYLX_cjs.getNodeKinds(graph)) {
     const registration = graph.nodes[kindName];
     map.set(kindName, {
       registration,
@@ -291,18 +276,16 @@ function buildNodeSchemaMap(graph) {
 }
 function buildEdgeSchemaMap(graph) {
   const map = /* @__PURE__ */ new Map();
-  for (const kindName of chunkEEYV6UOE_cjs.getEdgeKinds(graph)) {
+  for (const kindName of chunkT6SPUYLX_cjs.getEdgeKinds(graph)) {
     const registration = graph.edges[kindName];
     map.set(kindName, {
       registration,
-      schema: registration.type.schema,
-      fromKinds: new Set(registration.from.map((node) => node.kind)),
-      toKinds: new Set(registration.to.map((node) => node.kind))
+      schema: registration.type.schema
     });
   }
   return map;
 }
-async function processNodes(backend, graphId, nodes, schemas, options, result, errors, importedNodeIds) {
+async function processNodes(backend, graphId, registry, nodes, schemas, options, result, errors, importedNodeIds, lock) {
   const batchSize = options.batchSize;
   for (let index = 0; index < nodes.length; index += batchSize) {
     const batch = nodes.slice(index, index + batchSize);
@@ -310,9 +293,11 @@ async function processNodes(backend, graphId, nodes, schemas, options, result, e
       const importResult = await processNode(
         backend,
         graphId,
+        registry,
         node,
         schemas,
-        options
+        options,
+        lock
       );
       switch (importResult.status) {
         case "created": {
@@ -327,7 +312,9 @@ async function processNodes(backend, graphId, nodes, schemas, options, result, e
         }
         case "skipped": {
           result.nodes.skipped++;
-          importedNodeIds.add(makeNodeKey(node.kind, node.id));
+          if (importResult.liveTarget) {
+            importedNodeIds.add(makeNodeKey(node.kind, node.id));
+          }
           break;
         }
         case "error": {
@@ -343,16 +330,26 @@ async function processNodes(backend, graphId, nodes, schemas, options, result, e
     }
   }
 }
+async function catchUniquenessError(fn) {
+  try {
+    return { ok: true, value: await fn() };
+  } catch (error) {
+    if (error instanceof chunkJIEJCTDS_cjs.UniquenessError) {
+      return { ok: false, error: error.message };
+    }
+    throw error;
+  }
+}
 function validateValidityWindow(entity) {
   try {
-    chunkEEYV6UOE_cjs.validateOptionalCanonicalIsoDate(entity.validFrom, "validFrom");
-    chunkEEYV6UOE_cjs.validateOptionalCanonicalIsoDate(entity.validTo, "validTo");
+    chunkYC6PWTHY_cjs.validateOptionalCanonicalIsoDate(entity.validFrom, "validFrom");
+    chunkYC6PWTHY_cjs.validateOptionalCanonicalIsoDate(entity.validTo, "validTo");
     return void 0;
   } catch (error) {
     return error instanceof Error ? error.message : String(error);
   }
 }
-async function processNode(backend, graphId, node, schemas, options) {
+async function processNode(backend, graphId, registry, node, schemas, options, lock) {
   const schemaEntry = schemas.get(node.kind);
   if (!schemaEntry) {
     return { status: "error", error: `Unknown node kind: ${node.kind}` };
@@ -369,11 +366,14 @@ async function processNode(backend, graphId, node, schemas, options) {
   if (validityError !== void 0) {
     return { status: "error", error: validityError };
   }
+  const { registration } = schemaEntry;
+  const uniqueConstraints = registration.unique ?? [];
+  const writeContext = { graphId, registry, lock };
   const existing = await backend.getNode(graphId, node.kind, node.id);
   if (existing) {
     switch (options.onConflict) {
       case "skip": {
-        return { status: "skipped" };
+        return { status: "skipped", liveTarget: chunkUNNPKQUG_cjs.isLiveNodeRow(existing) };
       }
       case "error": {
         return {
@@ -382,18 +382,41 @@ async function processNode(backend, graphId, node, schemas, options) {
         };
       }
       case "update": {
-        await backend.updateNode({
-          graphId,
-          kind: node.kind,
-          id: node.id,
-          props: propsResult.data,
-          incrementVersion: true,
-          ...node.validTo !== void 0 && { validTo: node.validTo }
-        });
+        if (!chunkUNNPKQUG_cjs.isLiveNodeRow(existing)) {
+          return { status: "skipped", liveTarget: false };
+        }
+        const updateResult = await catchUniquenessError(
+          () => chunk5IQIX7LU_cjs.applyNodeUpdate(
+            writeContext,
+            {
+              existing,
+              schema: registration.type.schema,
+              validatedProps: propsResult.data,
+              uniqueConstraints,
+              ...node.validTo !== void 0 && { validTo: node.validTo }
+            },
+            backend
+          )
+        );
+        if (!updateResult.ok) {
+          return { status: "error", error: updateResult.error };
+        }
         return { status: "updated" };
       }
     }
   }
+  const uniquenessResult = await catchUniquenessError(
+    () => chunk5IQIX7LU_cjs.checkUniquenessConstraints(
+      { graphId, registry, backend },
+      node.kind,
+      node.id,
+      propsResult.data,
+      uniqueConstraints
+    )
+  );
+  if (!uniquenessResult.ok) {
+    return { status: "error", error: uniquenessResult.error };
+  }
   await backend.insertNode({
     graphId,
     kind: node.kind,
@@ -402,9 +425,20 @@ async function processNode(backend, graphId, node, schemas, options) {
     ...node.validFrom !== void 0 && { validFrom: node.validFrom },
     ...node.validTo !== void 0 && { validTo: node.validTo }
   });
+  await chunk5IQIX7LU_cjs.applyNodeInsertSideEffects(
+    writeContext,
+    {
+      kind: node.kind,
+      id: node.id,
+      schema: registration.type.schema,
+      props: propsResult.data,
+      uniqueConstraints
+    },
+    backend
+  );
   return { status: "created" };
 }
-async function processEdges(backend, graphId, edges, edgeSchemas, nodeSchemas, options, result, errors, importedNodeIds) {
+async function processEdges(backend, graphId, registry, edges, edgeSchemas, nodeSchemas, options, result, errors, importedNodeIds) {
   const batchSize = options.batchSize;
   for (let index = 0; index < edges.length; index += batchSize) {
     const batch = edges.slice(index, index + batchSize);
@@ -412,6 +446,7 @@ async function processEdges(backend, graphId, edges, edgeSchemas, nodeSchemas, o
       const importResult = await processEdge(
         backend,
         graphId,
+        registry,
         edge,
         edgeSchemas,
         nodeSchemas,
@@ -444,7 +479,7 @@ async function processEdges(backend, graphId, edges, edgeSchemas, nodeSchemas, o
     }
   }
 }
-async function processEdge(backend, graphId, edge, edgeSchemas, nodeSchemas, options, importedNodeIds) {
+async function processEdge(backend, graphId, registry, edge, edgeSchemas, nodeSchemas, options, importedNodeIds) {
   const schemaEntry = edgeSchemas.get(edge.kind);
   if (!schemaEntry) {
     return { status: "error", error: `Unknown edge kind: ${edge.kind}` };
@@ -458,17 +493,15 @@ async function processEdge(backend, graphId, edge, edgeSchemas, nodeSchemas, opt
   if (!nodeSchemas.has(edge.to.kind)) {
     return { status: "error", error: `Unknown to node kind: ${edge.to.kind}` };
   }
-  if (!schemaEntry.fromKinds.has(edge.from.kind)) {
-    return {
-      status: "error",
-      error: `Edge ${edge.kind} does not allow from kind: ${edge.from.kind}`
-    };
-  }
-  if (!schemaEntry.toKinds.has(edge.to.kind)) {
-    return {
-      status: "error",
-      error: `Edge ${edge.kind} does not allow to kind: ${edge.to.kind}`
-    };
+  const endpointError = chunk5IQIX7LU_cjs.validateEdgeEndpoints(
+    edge.kind,
+    edge.from.kind,
+    edge.to.kind,
+    schemaEntry.registration,
+    registry
+  );
+  if (endpointError !== void 0) {
+    return { status: "error", error: endpointError.message };
   }
   if (options.validateReferences) {
     const fromKey = makeNodeKey(edge.from.kind, edge.from.id);
@@ -479,7 +512,7 @@ async function processEdge(backend, graphId, edge, edgeSchemas, nodeSchemas, opt
         edge.from.kind,
         edge.from.id
       );
-      if (!fromExists) {
+      if (fromExists === void 0 || !chunkUNNPKQUG_cjs.isLiveNodeRow(fromExists)) {
         return {
           status: "error",
           error: `From node not found: ${edge.from.kind}:${edge.from.id}`
@@ -488,7 +521,7 @@ async function processEdge(backend, graphId, edge, edgeSchemas, nodeSchemas, opt
     }
     if (!importedNodeIds.has(toKey)) {
       const toExists = await backend.getNode(graphId, edge.to.kind, edge.to.id);
-      if (!toExists) {
+      if (toExists === void 0 || !chunkUNNPKQUG_cjs.isLiveNodeRow(toExists)) {
         return {
           status: "error",
           error: `To node not found: ${edge.to.kind}:${edge.to.id}`
@@ -512,12 +545,18 @@ async function processEdge(backend, graphId, edge, edgeSchemas, nodeSchemas, opt
   if (existing) {
     switch (options.onConflict) {
       case "skip": {
-        return { status: "skipped" };
+        return {
+          status: "skipped",
+          liveTarget: existing.deleted_at === void 0
+        };
       }
       case "error": {
         return { status: "error", error: `Edge already exists: ${edge.id}` };
       }
       case "update": {
+        if (existing.deleted_at !== void 0) {
+          return { status: "skipped", liveTarget: false };
+        }
         await backend.updateEdge({
           graphId,
           id: edge.id,
@@ -620,5 +659,5 @@ exports.InterchangeNodeSchema = InterchangeNodeSchema;
 exports.UnknownPropertyStrategySchema = UnknownPropertyStrategySchema;
 exports.exportGraph = exportGraph;
 exports.importGraph = importGraph;
-//# sourceMappingURL=chunk-SB65GJNY.cjs.map
-//# sourceMappingURL=chunk-SB65GJNY.cjs.map
+//# sourceMappingURL=chunk-KNHYNQQ3.cjs.map
+//# sourceMappingURL=chunk-KNHYNQQ3.cjs.map