@nicia-ai/typegraph 0.28.0 → 0.28.1

package/dist/chunk-FFHW2JEK.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+// src/schema/canonical.ts
+function sortedReplacer(_key, value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const sorted = {};
+    for (const key of Object.keys(value).toSorted()) {
+      sorted[key] = value[key];
+    }
+    return sorted;
+  }
+  return value;
+}
+function canonicalEqual(a, b) {
+  return JSON.stringify(a, sortedReplacer) === JSON.stringify(b, sortedReplacer);
+}
+
+// src/utils/sql-errors.ts
+var MISSING_TABLE_PATTERNS = [
+  "no such table",
+  // SQLite
+  "does not exist",
+  // PostgreSQL ("relation ... does not exist")
+  "SQLITE_ERROR"
+  // D1 / Durable Objects error code
+];
+var POSTGRES_UNDEFINED_TABLE_CODE = "42P01";
+function* errorChain(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== void 0 && current !== null && !seen.has(current)) {
+    seen.add(current);
+    yield current;
+    current = current instanceof Error ? current.cause : void 0;
+  }
+}
+function isPostgresUndefinedTable(link) {
+  return typeof link === "object" && link !== null && "code" in link && link.code === POSTGRES_UNDEFINED_TABLE_CODE;
+}
+function isMissingTableError(error) {
+  for (const link of errorChain(error)) {
+    if (isPostgresUndefinedTable(link)) return true;
+    const message = link instanceof Error ? link.message : String(link);
+    if (MISSING_TABLE_PATTERNS.some((pattern) => message.includes(pattern))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+exports.canonicalEqual = canonicalEqual;
+exports.isMissingTableError = isMissingTableError;
+exports.sortedReplacer = sortedReplacer;
+//# sourceMappingURL=chunk-FFHW2JEK.cjs.map
+//# sourceMappingURL=chunk-FFHW2JEK.cjs.map

package/dist/chunk-FFHW2JEK.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema/canonical.ts","../src/utils/sql-errors.ts"],"names":[],"mappings":";;;AAiBO,SAAS,cAAA,CAAe,MAAc,KAAA,EAAyB;AACpE,EAAA,IAAI,KAAA,KAAU,QAAQ,OAAO,KAAA,KAAU,YAAY,CAAC,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxE,IAAA,MAAM,SAAkC,EAAC;AACzC,IAAA,KAAA,MAAW,OAAO,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA,CAAE,UAAS,EAAG;AAC/C,MAAA,MAAA,CAAO,GAAG,CAAA,GAAK,KAAA,CAAkC,GAAG,CAAA;AAAA,IACtD;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,OAAO,KAAA;AACT;AAaO,SAAS,cAAA,CAAe,GAAY,CAAA,EAAqB;AAC9D,EAAA,OACE,IAAA,CAAK,UAAU,CAAA,EAAG,cAAc,MAAM,IAAA,CAAK,SAAA,CAAU,GAAG,cAAc,CAAA;AAE1E;;;ACtBA,IAAM,sBAAA,GAAyB;AAAA,EAC7B,eAAA;AAAA;AAAA,EACA,gBAAA;AAAA;AAAA,EACA;AAAA;AACF,CAAA;AASA,IAAM,6BAAA,GAAgC,OAAA;AAOtC,UAAU,WAAW,KAAA,EAAgD;AACnE,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAa;AAC9B,EAAA,IAAI,OAAA,GAAmB,KAAA;AACvB,EAAA,OAAO,OAAA,KAAY,UAAa,OAAA,KAAY,IAAA,IAAQ,CAAC,IAAA,CAAK,GAAA,CAAI,OAAO,CAAA,EAAG;AACtE,IAAA,IAAA,CAAK,IAAI,OAAO,CAAA;AAChB,IAAA,MAAM,OAAA;AACN,IAAA,OAAA,GAAU,OAAA,YAAmB,KAAA,GAAQ,OAAA,CAAQ,KAAA,GAAQ,MAAA;AAAA,EACvD;AACF;AAMA,SAAS,yBAAyB,IAAA,EAAwB;AACxD,EAAA,OACE,OAAO,SAAS,QAAA,IAChB,IAAA,KAAS,QACT,MAAA,IAAU,IAAA,IACT,KAAsC,IAAA,KACrC,6BAAA;AAEN;AAEO,SAAS,oBAAoB,KAAA,EAAyB;AAC3D,EAAA,KAAA,MAAW,IAAA,IAAQ,UAAA,CAAW,KAAK,CAAA,EAAG;AACpC,IAAA,IAAI,wBAAA,CAAyB,IAAI,CAAA,EAAG,OAAO,IAAA;AAC3C,IAAA,MAAM,UAAU,IAAA,YAAgB,KAAA,GAAQ,IAAA,CAAK,OAAA,GAAU,OAAO,IAAI,CAAA;AAClE,IAAA,IAAI,sBAAA,CAAuB,KAAK,CAAC,OAAA,KAAY,QAAQ,QAAA,CAAS,OAAO,CAAC,CAAA,EAAG;AACvE,MAAA,OAAO,IAAA;AAAA,IACT;AAAA,EACF;AACA,EAAA,OAAO,KAAA;AACT","file":"chunk-FFHW2JEK.cjs","sourcesContent":["/**\n * Canonical-form helpers for deterministic schema serialization.\n *\n * Used by both content-hashing (`computeSchemaHash`) and structural diffing\n * (`computeSchemaDiff`) to ensure that semantically-equivalent objects with\n * differently-ordered keys produce identical canonical strings.\n */\n\n/**\n * `JSON.stringify` replacer that sorts object keys recursively.\n *\n * Apply via `JSON.stringify(value, sortedReplacer)` to obtain output in\n * which sibling keys at every depth appear in lexicographic order.\n *\n * Arrays are passed through unchanged — array order is semantically\n * meaningful and must not be normalized.\n */\nexport function sortedReplacer(_key: string, value: unknown): unknown {\n  if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n    const sorted: Record<string, unknown> = {};\n    for (const key of Object.keys(value).toSorted()) {\n      sorted[key] = (value as Record<string, unknown>)[key];\n    }\n    return sorted;\n  }\n  return value;\n}\n\n/**\n * Compare two values for canonical-form equality.\n *\n * Returns `true` when both values produce identical JSON under `sortedReplacer`\n * — i.e., they have the same JSON structure regardless of object key order.\n * Used by diff machinery to detect semantic changes in JSON-shaped fields.\n *\n * Note: callers must handle `undefined` themselves — `JSON.stringify(undefined)`\n * returns `undefined`, so two `undefined` inputs would compare equal here, which\n * may or may not be the desired semantics depending on context.\n */\nexport function canonicalEqual(a: unknown, b: unknown): boolean {\n  return (\n    JSON.stringify(a, sortedReplacer) === JSON.stringify(b, sortedReplacer)\n  );\n}\n","/**\n * Cross-dialect detection of \"this relation does not exist yet\" errors.\n *\n * Shared so the schema bootstrap (`loadActiveSchemaWithBootstrap`) and\n * the durable contribution-materialization gate (#135) agree on what a\n * missing-table failure looks like, and — critically — so neither one\n * swallows a genuine system fault (connection/permission/driver error)\n * as a benign \"not bootstrapped yet\".\n *\n * Detection walks the error's `cause` chain because Drizzle (>= the\n * `DrizzleQueryError` era, drizzle-orm ≥ 0.36) wraps every failure from a\n * query-builder call (`db.select()`, `db.insert()`, …): the wrapper's\n * `.message` becomes the failed query text and the real driver error —\n * which carries both the missing-relation text and the SQLSTATE — is\n * preserved on `.cause`. node-postgres / postgres-js nest the pg error\n * one link deep; better-sqlite3 throws it unwrapped; raw `client.query()`\n * fast paths surface it directly. Walking the chain makes the check\n * wrapper- and driver-agnostic instead of only matching the outermost\n * `.message`, which on Postgres is just the SQL string.\n */\n\nconst MISSING_TABLE_PATTERNS = [\n  \"no such table\", // SQLite\n  \"does not exist\", // PostgreSQL (\"relation ... does not exist\")\n  \"SQLITE_ERROR\", // D1 / Durable Objects error code\n] as const;\n\n/**\n * SQLSTATE for PostgreSQL `undefined_table`. Preferred over the\n * human-readable message: it is locale-independent (the \"... does not\n * exist\" text is translated under a non-English `lc_messages`) and is\n * preserved on the underlying driver error even when Drizzle overwrites\n * `.message` with the query text.\n */\nconst POSTGRES_UNDEFINED_TABLE_CODE = \"42P01\";\n\n/**\n * Yields an error and each error reachable by following `.cause`,\n * outermost first. `seen` guards the pathological cyclic-cause case so a\n * self-referential chain can't spin forever.\n */\nfunction* errorChain(error: unknown): Generator<unknown, void, void> {\n  const seen = new Set<unknown>();\n  let current: unknown = error;\n  while (current !== undefined && current !== null && !seen.has(current)) {\n    seen.add(current);\n    yield current;\n    current = current instanceof Error ? current.cause : undefined;\n  }\n}\n\n/**\n * Whether a single chain link is a PostgreSQL `undefined_table` failure,\n * identified by its SQLSTATE rather than a message substring.\n */\nfunction isPostgresUndefinedTable(link: unknown): boolean {\n  return (\n    typeof link === \"object\" &&\n    link !== null &&\n    \"code\" in link &&\n    (link as Readonly<{ code?: unknown }>).code ===\n      POSTGRES_UNDEFINED_TABLE_CODE\n  );\n}\n\nexport function isMissingTableError(error: unknown): boolean {\n  for (const link of errorChain(error)) {\n    if (isPostgresUndefinedTable(link)) return true;\n    const message = link instanceof Error ? link.message : String(link);\n    if (MISSING_TABLE_PATTERNS.some((pattern) => message.includes(pattern))) {\n      return true;\n    }\n  }\n  return false;\n}\n"]}

package/dist/{chunk-33K3ZYFG.cjs → chunk-NMOE2ZEU.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunk2E4VTD2E_cjs = require('./chunk-2E4VTD2E.cjs');
+var chunkNYQFPGYP_cjs = require('./chunk-NYQFPGYP.cjs');
 var chunkLYRUNG6E_cjs = require('./chunk-LYRUNG6E.cjs');
 var chunkPN37HVAV_cjs = require('./chunk-PN37HVAV.cjs');
 var chunkYEDQLNVE_cjs = require('./chunk-YEDQLNVE.cjs');
@@ -70,7 +70,7 @@ function resolveSqliteClient(db) {
   return sqliteClient;
 }
 function getOrCreatePreparedStatement(cache, sqliteClient, sqlText, cacheMax) {
-  return chunk2E4VTD2E_cjs.getOrCreateLru(
+  return chunkNYQFPGYP_cjs.getOrCreateLru(
     cache,
     sqlText,
     cacheMax,
@@ -106,7 +106,7 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
     supportsCompiledExecution: sqliteClient !== void 0,
     transactionMode
   };
-  const compile = (query) => chunk2E4VTD2E_cjs.compileQueryWithDialect(db, query, "SQLite");
+  const compile = (query) => chunkNYQFPGYP_cjs.compileQueryWithDialect(db, query, "SQLite");
   if (sqliteClient !== void 0) {
     let executeCompiled2 = function(compiledQuery) {
       const preparedStatement = getOrCreatePreparedStatement(
@@ -177,10 +177,10 @@ var SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(
   1,
   SQLITE_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
 );
-var toNodeRow = chunk2E4VTD2E_cjs.createNodeRowMapper(chunk2E4VTD2E_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toEdgeRow = chunk2E4VTD2E_cjs.createEdgeRowMapper(chunk2E4VTD2E_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toUniqueRow = chunk2E4VTD2E_cjs.createUniqueRowMapper(chunk2E4VTD2E_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toSchemaVersionRow = chunk2E4VTD2E_cjs.createSchemaVersionRowMapper(chunk2E4VTD2E_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toNodeRow = chunkNYQFPGYP_cjs.createNodeRowMapper(chunkNYQFPGYP_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toEdgeRow = chunkNYQFPGYP_cjs.createEdgeRowMapper(chunkNYQFPGYP_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toUniqueRow = chunkNYQFPGYP_cjs.createUniqueRowMapper(chunkNYQFPGYP_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toSchemaVersionRow = chunkNYQFPGYP_cjs.createSchemaVersionRowMapper(chunkNYQFPGYP_cjs.SQLITE_ROW_MAPPER_CONFIG);
 var PENDING_FOREVER = new Promise(noop);
 function pendingForever() {
   return PENDING_FOREVER;
@@ -272,7 +272,7 @@ function createSqliteOperationBackend(options) {
       await db.run(query);
     });
   }
-  const commonBackend = chunk2E4VTD2E_cjs.createCommonOperationBackend({
+  const commonBackend = chunkNYQFPGYP_cjs.createCommonOperationBackend({
     batchConfig: {
       checkUniqueBatchChunkSize: SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE,
       edgeInsertBatchSize: SQLITE_EDGE_INSERT_BATCH_SIZE,
@@ -285,7 +285,7 @@ function createSqliteOperationBackend(options) {
       execGet,
       execRun
     },
-    nowIso: chunk2E4VTD2E_cjs.nowIso,
+    nowIso: chunkNYQFPGYP_cjs.nowIso,
     operationStrategy,
     rowMappers: {
       toEdgeRow,
@@ -307,7 +307,7 @@ function createSqliteOperationBackend(options) {
     async upsertEmbedding(params) {
       const query = operationStrategy.buildUpsertEmbedding(
         params,
-        chunk2E4VTD2E_cjs.nowIso()
+        chunkNYQFPGYP_cjs.nowIso()
       );
       await execRun(query);
     },
@@ -346,14 +346,14 @@ function createSqliteOperationBackend(options) {
         ...params.indexParams?.efConstruction === void 0 ? {} : { hnswEfConstruction: params.indexParams.efConstruction },
         ...params.indexParams?.lists === void 0 ? {} : { ivfflatLists: params.indexParams.lists }
       };
-      const result = chunk2E4VTD2E_cjs.createSqliteVectorIndex(indexOptions);
+      const result = chunkNYQFPGYP_cjs.createSqliteVectorIndex(indexOptions);
       if (!result.success) {
         throw new Error(result.message ?? "Failed to create SQLite vector index");
       }
       return Promise.resolve();
     },
     dropVectorIndex(params) {
-      const result = chunk2E4VTD2E_cjs.dropSqliteVectorIndex(
+      const result = chunkNYQFPGYP_cjs.dropSqliteVectorIndex(
         params.graphId,
         params.nodeKind,
         params.fieldPath
@@ -365,7 +365,7 @@ function createSqliteOperationBackend(options) {
     },
     // === Fulltext Operations ===
     async upsertFulltext(params) {
-      const timestamp = chunk2E4VTD2E_cjs.nowIso();
+      const timestamp = chunkNYQFPGYP_cjs.nowIso();
       const statements = operationStrategy.buildUpsertFulltext(
         params,
         timestamp
@@ -382,7 +382,7 @@ function createSqliteOperationBackend(options) {
     },
     async upsertFulltextBatch(params) {
       if (params.rows.length === 0) return;
-      const timestamp = chunk2E4VTD2E_cjs.nowIso();
+      const timestamp = chunkNYQFPGYP_cjs.nowIso();
       const statements = operationStrategy.buildUpsertFulltextBatch(
         params,
         timestamp
@@ -403,7 +403,7 @@ function createSqliteOperationBackend(options) {
       const rows = await execAll(query);
       return rows.map((row, index) => ({
         nodeId: row.node_id,
-        score: chunk2E4VTD2E_cjs.coerceNumericScore(row.score),
+        score: chunkNYQFPGYP_cjs.coerceNumericScore(row.score),
         rank: index + 1,
         ...row.snippet === null ? {} : { snippet: row.snippet }
       }));
@@ -422,7 +422,7 @@ function createSqliteOperationBackend(options) {
   return operationBackend;
 }
 function createSqliteBackend(db, options = {}) {
-  const tables2 = options.tables ?? chunk2E4VTD2E_cjs.tables2;
+  const tables2 = options.tables ?? chunkNYQFPGYP_cjs.tables2;
   const fulltextStrategy = options.fulltext ?? chunkPN37HVAV_cjs.fts5Strategy;
   const profileHints = options.executionProfile ?? {};
   const executionAdapter = createSqliteExecutionAdapter(db, { profileHints });
@@ -440,7 +440,7 @@ function createSqliteBackend(db, options = {}) {
     fulltext: tables2.fulltextTableName,
     uniques: drizzleOrm.getTableName(tables2.uniques)
   };
-  const operationStrategy = chunk2E4VTD2E_cjs.createSqliteOperationStrategy(
+  const operationStrategy = chunkNYQFPGYP_cjs.createSqliteOperationStrategy(
     tables2,
     fulltextStrategy
   );
@@ -529,7 +529,7 @@ function createSqliteBackend(db, options = {}) {
   }
   const matTable = tables2.contributionMaterializations;
   async function ensureContributionMaterializationsTableImpl() {
-    await db.run(drizzleOrm.sql.raw(chunk2E4VTD2E_cjs.generateSqliteCreateTableSQL(matTable)));
+    await db.run(drizzleOrm.sql.raw(chunkNYQFPGYP_cjs.generateSqliteCreateTableSQL(matTable)));
   }
   async function getContributionMaterializationRow(identity) {
     const rows = await db.select().from(matTable).where(
@@ -542,16 +542,16 @@ function createSqliteBackend(db, options = {}) {
     );
     const row = rows[0];
     if (row === void 0) return void 0;
-    return chunk2E4VTD2E_cjs.mapContributionMaterializationRow(
+    return chunkNYQFPGYP_cjs.mapContributionMaterializationRow(
       row,
-      chunk2E4VTD2E_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
+      chunkNYQFPGYP_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
     );
   }
   async function recordContributionMaterializationRow(params) {
     await db.insert(matTable).values(
-      chunk2E4VTD2E_cjs.buildContributionInsertValues(
+      chunkNYQFPGYP_cjs.buildContributionInsertValues(
         params,
-        chunk2E4VTD2E_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.encode
+        chunkNYQFPGYP_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.encode
       )
     ).onConflictDoUpdate({
       target: [
@@ -560,13 +560,13 @@ function createSqliteBackend(db, options = {}) {
         matTable.owner,
         matTable.tableName
       ],
-      set: chunk2E4VTD2E_cjs.buildContributionOnConflictSet(
+      set: chunkNYQFPGYP_cjs.buildContributionOnConflictSet(
         matTable.materializedAt,
         params.materializedAt
       )
     });
   }
-  const contributionMaterializer = chunk2E4VTD2E_cjs.createContributionMaterializer({
+  const contributionMaterializer = chunkNYQFPGYP_cjs.createContributionMaterializer({
     dialect: "sqlite",
     fulltextStrategy,
     fulltextTableName: tables2.fulltextTableName,
@@ -587,12 +587,12 @@ function createSqliteBackend(db, options = {}) {
       fulltextStrategy,
       hasVectorEmbeddings
     });
-    return chunk2E4VTD2E_cjs.gateFulltext(txBackend, contributionMaterializer.assertInitialized);
+    return chunkNYQFPGYP_cjs.gateFulltext(txBackend, contributionMaterializer.assertInitialized);
   }
   const backend = {
     ...operations,
     async bootstrapTables() {
-      const statements = chunk2E4VTD2E_cjs.generateSqliteDDL(tables2, fulltextStrategy);
+      const statements = chunkNYQFPGYP_cjs.generateSqliteDDL(tables2, fulltextStrategy);
       for (const statement of statements) {
         await db.run(drizzleOrm.sql.raw(statement));
       }
@@ -602,7 +602,7 @@ function createSqliteBackend(db, options = {}) {
     // uninitialized database throws `StoreNotInitializedError` rather
     // than self-healing (#135). Shared verbatim with the tx-scoped gate
     // via `gateFulltextMethods`.
-    ...chunk2E4VTD2E_cjs.gateFulltextMethods(
+    ...chunkNYQFPGYP_cjs.gateFulltextMethods(
       operations,
       contributionMaterializer.assertInitialized
     ),
@@ -611,7 +611,7 @@ function createSqliteBackend(db, options = {}) {
     },
     async ensureIndexMaterializationsTable() {
       await db.run(
-        drizzleOrm.sql.raw(chunk2E4VTD2E_cjs.generateSqliteCreateTableSQL(tables2.indexMaterializations))
+        drizzleOrm.sql.raw(chunkNYQFPGYP_cjs.generateSqliteCreateTableSQL(tables2.indexMaterializations))
       );
     },
     async getIndexMaterialization(indexName) {
@@ -619,26 +619,26 @@ function createSqliteBackend(db, options = {}) {
       const rows = await db.select().from(t).where(drizzleOrm.eq(t.indexName, indexName));
       const row = rows[0];
       if (row === void 0) return void 0;
-      return chunk2E4VTD2E_cjs.mapMaterializationRow(row, chunk2E4VTD2E_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode);
+      return chunkNYQFPGYP_cjs.mapMaterializationRow(row, chunkNYQFPGYP_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode);
     },
     async getIndexMaterializations(statusKeys) {
       if (statusKeys.length === 0) return [];
       const t = tables2.indexMaterializations;
       const rows = await db.select().from(t).where(drizzleOrm.inArray(t.indexName, [...statusKeys]));
       return rows.map(
-        (row) => chunk2E4VTD2E_cjs.mapMaterializationRow(row, chunk2E4VTD2E_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode)
+        (row) => chunkNYQFPGYP_cjs.mapMaterializationRow(row, chunkNYQFPGYP_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode)
       );
     },
     async recordIndexMaterialization(params) {
       const t = tables2.indexMaterializations;
       await db.insert(t).values(
-        chunk2E4VTD2E_cjs.buildMaterializationInsertValues(
+        chunkNYQFPGYP_cjs.buildMaterializationInsertValues(
           params,
-          chunk2E4VTD2E_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.encode
+          chunkNYQFPGYP_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.encode
         )
       ).onConflictDoUpdate({
         target: t.indexName,
-        set: chunk2E4VTD2E_cjs.buildMaterializationOnConflictSet(
+        set: chunkNYQFPGYP_cjs.buildMaterializationOnConflictSet(
           t.materializedAt,
           params.materializedAt
         )
@@ -657,37 +657,37 @@ function createSqliteBackend(db, options = {}) {
       await contributionMaterializer.assertInitialized(graphId);
     },
     async ensureKindRemovalsTable() {
-      await db.run(drizzleOrm.sql.raw(chunk2E4VTD2E_cjs.generateSqliteCreateTableSQL(tables2.kindRemovals)));
+      await db.run(drizzleOrm.sql.raw(chunkNYQFPGYP_cjs.generateSqliteCreateTableSQL(tables2.kindRemovals)));
     },
     async getPendingKindRemovals(graphId) {
       const t = tables2.kindRemovals;
       const rows = await db.select().from(t).where(drizzleOrm.and(drizzleOrm.eq(t.graphId, graphId), drizzleOrm.isNull(t.removedAt)));
       return rows.map(
-        (row) => chunk2E4VTD2E_cjs.mapKindRemovalRow(row, chunk2E4VTD2E_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
+        (row) => chunkNYQFPGYP_cjs.mapKindRemovalRow(row, chunkNYQFPGYP_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
       );
     },
     async getAllKindRemovals(graphId) {
       const t = tables2.kindRemovals;
       const rows = await db.select().from(t).where(drizzleOrm.eq(t.graphId, graphId));
       return rows.map(
-        (row) => chunk2E4VTD2E_cjs.mapKindRemovalRow(row, chunk2E4VTD2E_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
+        (row) => chunkNYQFPGYP_cjs.mapKindRemovalRow(row, chunkNYQFPGYP_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
       );
     },
     async recordKindRemoval(params) {
       const t = tables2.kindRemovals;
       await db.insert(t).values(
-        chunk2E4VTD2E_cjs.buildKindRemovalInsertValues(
+        chunkNYQFPGYP_cjs.buildKindRemovalInsertValues(
           params,
-          chunk2E4VTD2E_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.encode
+          chunkNYQFPGYP_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.encode
         )
       ).onConflictDoUpdate({
         target: [t.graphId, t.kindName, t.entity, t.schemaVersion],
-        set: chunk2E4VTD2E_cjs.buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
+        set: chunkNYQFPGYP_cjs.buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
       });
     },
     async ensureReconciliationMarkersTable() {
       await db.run(
-        drizzleOrm.sql.raw(chunk2E4VTD2E_cjs.generateSqliteCreateTableSQL(tables2.reconciliationMarkers))
+        drizzleOrm.sql.raw(chunkNYQFPGYP_cjs.generateSqliteCreateTableSQL(tables2.reconciliationMarkers))
       );
     },
     async ensureRuntimeContributions(graphId) {
@@ -747,7 +747,7 @@ function createSqliteBackend(db, options = {}) {
           db.run(drizzleOrm.sql`BEGIN`);
           try {
             const result = await fn(
-              chunk2E4VTD2E_cjs.gateFulltext(
+              chunkNYQFPGYP_cjs.gateFulltext(
                 txBackend,
                 contributionMaterializer.assertInitialized
               ),
@@ -779,7 +779,7 @@ function createSqliteBackend(db, options = {}) {
           "Cross-store atomicity is unavailable on this SQLite backend: transactions are disabled (transactionMode: 'none'). Adopting an external transaction here would let the caller's relational write commit with no way to roll back the graph write. Configure a driver that supports transactions (better-sqlite3, libsql, bun:sqlite)."
         );
       }
-      chunk2E4VTD2E_cjs.assertAdoptedDialect(
+      chunkNYQFPGYP_cjs.assertAdoptedDialect(
         externalTx,
         sqliteCore.BaseSQLiteDatabase,
         "sqlite"
@@ -809,5 +809,5 @@ function createTransactionBackend(options) {
 }
 
 exports.createSqliteBackend = createSqliteBackend;
-//# sourceMappingURL=chunk-33K3ZYFG.cjs.map
-//# sourceMappingURL=chunk-33K3ZYFG.cjs.map
+//# sourceMappingURL=chunk-NMOE2ZEU.cjs.map
+//# sourceMappingURL=chunk-NMOE2ZEU.cjs.map