latticesql 4.3.5 → 4.3.7

package/dist/cli.js

@@ -1948,6 +1948,17 @@ function rewriteParams(sql) {
 function rewrite(sql) {
   return rewriteParams(translateDialect(sql));
 }
+async function execQ(runner, sql, params) {
+  try {
+    return await runner.query(rewrite(sql), params ?? []);
+  } catch (err) {
+    if (err instanceof Error && !err.message.includes("[lattice-sql]")) {
+      err.message += `
+[lattice-sql] failing statement: ${sql.replace(/\s+/g, " ").trim().slice(0, 300)}`;
+    }
+    throw err;
+  }
+}
 var _moduleContext, SYNC_NOT_SUPPORTED_MSG, PostgresAdapter, POSTGRES_POLYFILLS;
 var init_postgres = __esm({
   "src/db/postgres.ts"() {
@@ -2026,16 +2037,16 @@ var init_postgres = __esm({
       // these calls await DB I/O.
       async runAsync(sql, params = []) {
         const pool = await this._readyPool();
-        await pool.query(rewrite(sql), params);
+        await execQ(pool, sql, params);
       }
       async getAsync(sql, params = []) {
         const pool = await this._readyPool();
-        const r6 = await pool.query(rewrite(sql), params);
+        const r6 = await execQ(pool, sql, params);
         return r6.rows[0];
       }
       async allAsync(sql, params = []) {
         const pool = await this._readyPool();
-        const r6 = await pool.query(rewrite(sql), params);
+        const r6 = await execQ(pool, sql, params);
         return r6.rows;
       }
       /**
@@ -2053,21 +2064,20 @@ var init_postgres = __esm({
        * client for the transaction lifetime and avoid the per-call setup.
        */
       prepareAsync(sql) {
-        const rewritten = rewrite(sql);
         return {
           run: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return { changes: r6.rowCount ?? 0, lastInsertRowid: 0 };
           },
           get: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return r6.rows[0];
           },
           all: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return r6.rows;
           }
         };
@@ -2117,7 +2127,7 @@ var init_postgres = __esm({
         if (upper.includes("PRIMARY KEY")) return;
         const translated = translateTypeSpec(typeSpec);
         const pool = await this._readyPool();
-        await pool.query(`ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" ${translated}`);
+        await execQ(pool, `ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" ${translated}`);
       }
       /**
        * Run `fn` against a single checked-out pool client wrapped in BEGIN/COMMIT.
@@ -2135,15 +2145,15 @@ var init_postgres = __esm({
         const client = await pool.connect();
         const tx = {
           run: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return { changes: r6.rowCount ?? 0 };
           },
           get: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return r6.rows[0];
           },
           all: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return r6.rows;
           }
         };
@@ -58434,14 +58444,40 @@ async function normalizeEmptyDeletedAt(db) {
     await db.migrate([
       {
         version: `${DELETED_AT_SENTINEL}:all`,
+        // TYPE-AWARE: only a text-like deleted_at column can hold the legacy ''
+        // sentinel. A column that is a real `timestamptz` (some clouds' deleted_at
+        // is) MUST be skipped: the predicate `deleted_at = ''` forces Postgres to
+        // parse `''::timestamptz` at PLAN time — invalid input that throws regardless
+        // of data (a timestamptz column can't even hold ''), which aborted the entire
+        // workspace open. We BLACKLIST the non-text types (timestamp/date/time,
+        // numeric, boolean, json, uuid, bytea, xml) rather than allow-list text — so
+        // text-like columns we don't enumerate (citext, a DOMAIN over text, a custom
+        // text type) are still normalized instead of silently leaving '' rows that
+        // 4.x's `deleted_at IS NULL` predicate would read as DELETED. PER-TABLE FAULT
+        // ISOLATION is the backstop: each table's UPDATE runs in its own
+        // subtransaction, so an exotic type that still errors on `= ''` (enum, inet,
+        // interval, array) — or a blocking trigger/lock — is warned + skipped, never
+        // fatal to the open.
         sql: `DO $LATTICE_DAU$
   DECLARE r record;
 BEGIN
   FOR r IN
     SELECT table_name FROM information_schema.columns
-     WHERE table_schema = current_schema() AND column_name = 'deleted_at'
+     WHERE table_schema = current_schema()
+       AND column_name = 'deleted_at'
+       AND data_type NOT IN (
+         'timestamp with time zone', 'timestamp without time zone',
+         'date', 'time with time zone', 'time without time zone',
+         'integer', 'bigint', 'smallint', 'numeric', 'decimal',
+         'real', 'double precision', 'boolean', 'json', 'jsonb',
+         'bytea', 'uuid', 'xml'
+       )
   LOOP
-    EXECUTE format('UPDATE %I SET deleted_at = NULL WHERE deleted_at = ''''', r.table_name);
+    BEGIN
+      EXECUTE format('UPDATE %I SET deleted_at = NULL WHERE deleted_at = ''''', r.table_name);
+    EXCEPTION WHEN others THEN
+      RAISE WARNING 'lattice: skipped deleted_at normalization for %: %', r.table_name, SQLERRM;
+    END;
   END LOOP;
 END $LATTICE_DAU$;`
       }
@@ -82096,7 +82132,7 @@ function printHelp() {
   );
 }
 function getVersion() {
-  if (true) return "4.3.5";
+  if (true) return "4.3.7";
   try {
     const pkgPath = new URL("../package.json", import.meta.url).pathname;
     const pkg = JSON.parse(readFileSync26(pkgPath, "utf-8"));

package/dist/desktop-entry.js

@@ -2030,6 +2030,17 @@ function rewriteParams(sql) {
 function rewrite(sql) {
   return rewriteParams(translateDialect(sql));
 }
+async function execQ(runner, sql, params) {
+  try {
+    return await runner.query(rewrite(sql), params ?? []);
+  } catch (err) {
+    if (err instanceof Error && !err.message.includes("[lattice-sql]")) {
+      err.message += `
+[lattice-sql] failing statement: ${sql.replace(/\s+/g, " ").trim().slice(0, 300)}`;
+    }
+    throw err;
+  }
+}
 var _moduleContext, SYNC_NOT_SUPPORTED_MSG, PostgresAdapter, POSTGRES_POLYFILLS;
 var init_postgres = __esm({
   "src/db/postgres.ts"() {
@@ -2108,16 +2119,16 @@ var init_postgres = __esm({
       // these calls await DB I/O.
       async runAsync(sql, params = []) {
         const pool = await this._readyPool();
-        await pool.query(rewrite(sql), params);
+        await execQ(pool, sql, params);
       }
       async getAsync(sql, params = []) {
         const pool = await this._readyPool();
-        const r6 = await pool.query(rewrite(sql), params);
+        const r6 = await execQ(pool, sql, params);
         return r6.rows[0];
       }
       async allAsync(sql, params = []) {
         const pool = await this._readyPool();
-        const r6 = await pool.query(rewrite(sql), params);
+        const r6 = await execQ(pool, sql, params);
         return r6.rows;
       }
       /**
@@ -2135,21 +2146,20 @@ var init_postgres = __esm({
        * client for the transaction lifetime and avoid the per-call setup.
        */
       prepareAsync(sql) {
-        const rewritten = rewrite(sql);
         return {
           run: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return { changes: r6.rowCount ?? 0, lastInsertRowid: 0 };
           },
           get: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return r6.rows[0];
           },
           all: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return r6.rows;
           }
         };
@@ -2199,7 +2209,7 @@ var init_postgres = __esm({
         if (upper.includes("PRIMARY KEY")) return;
         const translated = translateTypeSpec(typeSpec);
         const pool = await this._readyPool();
-        await pool.query(`ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" ${translated}`);
+        await execQ(pool, `ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" ${translated}`);
       }
       /**
        * Run `fn` against a single checked-out pool client wrapped in BEGIN/COMMIT.
@@ -2217,15 +2227,15 @@ var init_postgres = __esm({
         const client = await pool.connect();
         const tx = {
           run: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return { changes: r6.rowCount ?? 0 };
           },
           get: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return r6.rows[0];
           },
           all: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return r6.rows;
           }
         };
@@ -58128,14 +58138,40 @@ async function normalizeEmptyDeletedAt(db) {
     await db.migrate([
       {
         version: `${DELETED_AT_SENTINEL}:all`,
+        // TYPE-AWARE: only a text-like deleted_at column can hold the legacy ''
+        // sentinel. A column that is a real `timestamptz` (some clouds' deleted_at
+        // is) MUST be skipped: the predicate `deleted_at = ''` forces Postgres to
+        // parse `''::timestamptz` at PLAN time — invalid input that throws regardless
+        // of data (a timestamptz column can't even hold ''), which aborted the entire
+        // workspace open. We BLACKLIST the non-text types (timestamp/date/time,
+        // numeric, boolean, json, uuid, bytea, xml) rather than allow-list text — so
+        // text-like columns we don't enumerate (citext, a DOMAIN over text, a custom
+        // text type) are still normalized instead of silently leaving '' rows that
+        // 4.x's `deleted_at IS NULL` predicate would read as DELETED. PER-TABLE FAULT
+        // ISOLATION is the backstop: each table's UPDATE runs in its own
+        // subtransaction, so an exotic type that still errors on `= ''` (enum, inet,
+        // interval, array) — or a blocking trigger/lock — is warned + skipped, never
+        // fatal to the open.
         sql: `DO $LATTICE_DAU$
   DECLARE r record;
 BEGIN
   FOR r IN
     SELECT table_name FROM information_schema.columns
-     WHERE table_schema = current_schema() AND column_name = 'deleted_at'
+     WHERE table_schema = current_schema()
+       AND column_name = 'deleted_at'
+       AND data_type NOT IN (
+         'timestamp with time zone', 'timestamp without time zone',
+         'date', 'time with time zone', 'time without time zone',
+         'integer', 'bigint', 'smallint', 'numeric', 'decimal',
+         'real', 'double precision', 'boolean', 'json', 'jsonb',
+         'bytea', 'uuid', 'xml'
+       )
   LOOP
-    EXECUTE format('UPDATE %I SET deleted_at = NULL WHERE deleted_at = ''''', r.table_name);
+    BEGIN
+      EXECUTE format('UPDATE %I SET deleted_at = NULL WHERE deleted_at = ''''', r.table_name);
+    EXCEPTION WHEN others THEN
+      RAISE WARNING 'lattice: skipped deleted_at normalization for %: %', r.table_name, SQLERRM;
+    END;
   END LOOP;
 END $LATTICE_DAU$;`
       }
@@ -81674,7 +81710,7 @@ ${e6.stack ?? ""}`
 }
 
 // src/desktop-entry.ts
-var VERSION2 = true ? "4.3.5" : "unknown";
+var VERSION2 = true ? "4.3.7" : "unknown";
 export {
   VERSION2 as VERSION,
   ensureRootForGui,

package/dist/index.cjs

@@ -1161,6 +1161,17 @@ function rewriteParams(sql) {
 function rewrite(sql) {
   return rewriteParams(translateDialect(sql));
 }
+async function execQ(runner, sql, params) {
+  try {
+    return await runner.query(rewrite(sql), params ?? []);
+  } catch (err) {
+    if (err instanceof Error && !err.message.includes("[lattice-sql]")) {
+      err.message += `
+[lattice-sql] failing statement: ${sql.replace(/\s+/g, " ").trim().slice(0, 300)}`;
+    }
+    throw err;
+  }
+}
 var import_node_path4, import_node_url, import_node_module3, import_meta3, _moduleContext, SYNC_NOT_SUPPORTED_MSG, PostgresAdapter, POSTGRES_POLYFILLS;
 var init_postgres = __esm({
   "src/db/postgres.ts"() {
@@ -1243,16 +1254,16 @@ var init_postgres = __esm({
       // these calls await DB I/O.
       async runAsync(sql, params = []) {
         const pool = await this._readyPool();
-        await pool.query(rewrite(sql), params);
+        await execQ(pool, sql, params);
       }
       async getAsync(sql, params = []) {
         const pool = await this._readyPool();
-        const r6 = await pool.query(rewrite(sql), params);
+        const r6 = await execQ(pool, sql, params);
         return r6.rows[0];
       }
       async allAsync(sql, params = []) {
         const pool = await this._readyPool();
-        const r6 = await pool.query(rewrite(sql), params);
+        const r6 = await execQ(pool, sql, params);
         return r6.rows;
       }
       /**
@@ -1270,21 +1281,20 @@ var init_postgres = __esm({
        * client for the transaction lifetime and avoid the per-call setup.
        */
       prepareAsync(sql) {
-        const rewritten = rewrite(sql);
         return {
           run: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return { changes: r6.rowCount ?? 0, lastInsertRowid: 0 };
           },
           get: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return r6.rows[0];
           },
           all: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return r6.rows;
           }
         };
@@ -1334,7 +1344,7 @@ var init_postgres = __esm({
         if (upper.includes("PRIMARY KEY")) return;
         const translated = translateTypeSpec(typeSpec);
         const pool = await this._readyPool();
-        await pool.query(`ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" ${translated}`);
+        await execQ(pool, `ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" ${translated}`);
       }
       /**
        * Run `fn` against a single checked-out pool client wrapped in BEGIN/COMMIT.
@@ -1352,15 +1362,15 @@ var init_postgres = __esm({
         const client = await pool.connect();
         const tx = {
           run: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return { changes: r6.rowCount ?? 0 };
           },
           get: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return r6.rows[0];
           },
           all: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return r6.rows;
           }
         };
@@ -62665,14 +62675,40 @@ async function normalizeEmptyDeletedAt(db) {
     await db.migrate([
       {
         version: `${DELETED_AT_SENTINEL}:all`,
+        // TYPE-AWARE: only a text-like deleted_at column can hold the legacy ''
+        // sentinel. A column that is a real `timestamptz` (some clouds' deleted_at
+        // is) MUST be skipped: the predicate `deleted_at = ''` forces Postgres to
+        // parse `''::timestamptz` at PLAN time — invalid input that throws regardless
+        // of data (a timestamptz column can't even hold ''), which aborted the entire
+        // workspace open. We BLACKLIST the non-text types (timestamp/date/time,
+        // numeric, boolean, json, uuid, bytea, xml) rather than allow-list text — so
+        // text-like columns we don't enumerate (citext, a DOMAIN over text, a custom
+        // text type) are still normalized instead of silently leaving '' rows that
+        // 4.x's `deleted_at IS NULL` predicate would read as DELETED. PER-TABLE FAULT
+        // ISOLATION is the backstop: each table's UPDATE runs in its own
+        // subtransaction, so an exotic type that still errors on `= ''` (enum, inet,
+        // interval, array) — or a blocking trigger/lock — is warned + skipped, never
+        // fatal to the open.
         sql: `DO $LATTICE_DAU$
   DECLARE r record;
 BEGIN
   FOR r IN
     SELECT table_name FROM information_schema.columns
-     WHERE table_schema = current_schema() AND column_name = 'deleted_at'
+     WHERE table_schema = current_schema()
+       AND column_name = 'deleted_at'
+       AND data_type NOT IN (
+         'timestamp with time zone', 'timestamp without time zone',
+         'date', 'time with time zone', 'time without time zone',
+         'integer', 'bigint', 'smallint', 'numeric', 'decimal',
+         'real', 'double precision', 'boolean', 'json', 'jsonb',
+         'bytea', 'uuid', 'xml'
+       )
   LOOP
-    EXECUTE format('UPDATE %I SET deleted_at = NULL WHERE deleted_at = ''''', r.table_name);
+    BEGIN
+      EXECUTE format('UPDATE %I SET deleted_at = NULL WHERE deleted_at = ''''', r.table_name);
+    EXCEPTION WHEN others THEN
+      RAISE WARNING 'lattice: skipped deleted_at normalization for %: %', r.table_name, SQLERRM;
+    END;
   END LOOP;
 END $LATTICE_DAU$;`
       }

package/dist/index.js

@@ -1153,6 +1153,17 @@ function rewriteParams(sql) {
 function rewrite(sql) {
   return rewriteParams(translateDialect(sql));
 }
+async function execQ(runner, sql, params) {
+  try {
+    return await runner.query(rewrite(sql), params ?? []);
+  } catch (err) {
+    if (err instanceof Error && !err.message.includes("[lattice-sql]")) {
+      err.message += `
+[lattice-sql] failing statement: ${sql.replace(/\s+/g, " ").trim().slice(0, 300)}`;
+    }
+    throw err;
+  }
+}
 var _moduleContext, SYNC_NOT_SUPPORTED_MSG, PostgresAdapter, POSTGRES_POLYFILLS;
 var init_postgres = __esm({
   "src/db/postgres.ts"() {
@@ -1231,16 +1242,16 @@ var init_postgres = __esm({
       // these calls await DB I/O.
       async runAsync(sql, params = []) {
         const pool = await this._readyPool();
-        await pool.query(rewrite(sql), params);
+        await execQ(pool, sql, params);
       }
       async getAsync(sql, params = []) {
         const pool = await this._readyPool();
-        const r6 = await pool.query(rewrite(sql), params);
+        const r6 = await execQ(pool, sql, params);
         return r6.rows[0];
       }
       async allAsync(sql, params = []) {
         const pool = await this._readyPool();
-        const r6 = await pool.query(rewrite(sql), params);
+        const r6 = await execQ(pool, sql, params);
         return r6.rows;
       }
       /**
@@ -1258,21 +1269,20 @@ var init_postgres = __esm({
        * client for the transaction lifetime and avoid the per-call setup.
        */
       prepareAsync(sql) {
-        const rewritten = rewrite(sql);
         return {
           run: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return { changes: r6.rowCount ?? 0, lastInsertRowid: 0 };
           },
           get: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return r6.rows[0];
           },
           all: async (...params) => {
             const pool = await this._readyPool();
-            const r6 = await pool.query(rewritten, params);
+            const r6 = await execQ(pool, sql, params);
             return r6.rows;
           }
         };
@@ -1322,7 +1332,7 @@ var init_postgres = __esm({
         if (upper.includes("PRIMARY KEY")) return;
         const translated = translateTypeSpec(typeSpec);
         const pool = await this._readyPool();
-        await pool.query(`ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" ${translated}`);
+        await execQ(pool, `ALTER TABLE "${table}" ADD COLUMN IF NOT EXISTS "${column}" ${translated}`);
       }
       /**
        * Run `fn` against a single checked-out pool client wrapped in BEGIN/COMMIT.
@@ -1340,15 +1350,15 @@ var init_postgres = __esm({
         const client = await pool.connect();
         const tx = {
           run: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return { changes: r6.rowCount ?? 0 };
           },
           get: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return r6.rows[0];
           },
           all: async (sql, params) => {
-            const r6 = await client.query(rewrite(sql), params ?? []);
+            const r6 = await execQ(client, sql, params);
             return r6.rows;
           }
         };
@@ -62365,14 +62375,40 @@ async function normalizeEmptyDeletedAt(db) {
     await db.migrate([
       {
         version: `${DELETED_AT_SENTINEL}:all`,
+        // TYPE-AWARE: only a text-like deleted_at column can hold the legacy ''
+        // sentinel. A column that is a real `timestamptz` (some clouds' deleted_at
+        // is) MUST be skipped: the predicate `deleted_at = ''` forces Postgres to
+        // parse `''::timestamptz` at PLAN time — invalid input that throws regardless
+        // of data (a timestamptz column can't even hold ''), which aborted the entire
+        // workspace open. We BLACKLIST the non-text types (timestamp/date/time,
+        // numeric, boolean, json, uuid, bytea, xml) rather than allow-list text — so
+        // text-like columns we don't enumerate (citext, a DOMAIN over text, a custom
+        // text type) are still normalized instead of silently leaving '' rows that
+        // 4.x's `deleted_at IS NULL` predicate would read as DELETED. PER-TABLE FAULT
+        // ISOLATION is the backstop: each table's UPDATE runs in its own
+        // subtransaction, so an exotic type that still errors on `= ''` (enum, inet,
+        // interval, array) — or a blocking trigger/lock — is warned + skipped, never
+        // fatal to the open.
         sql: `DO $LATTICE_DAU$
   DECLARE r record;
 BEGIN
   FOR r IN
     SELECT table_name FROM information_schema.columns
-     WHERE table_schema = current_schema() AND column_name = 'deleted_at'
+     WHERE table_schema = current_schema()
+       AND column_name = 'deleted_at'
+       AND data_type NOT IN (
+         'timestamp with time zone', 'timestamp without time zone',
+         'date', 'time with time zone', 'time without time zone',
+         'integer', 'bigint', 'smallint', 'numeric', 'decimal',
+         'real', 'double precision', 'boolean', 'json', 'jsonb',
+         'bytea', 'uuid', 'xml'
+       )
   LOOP
-    EXECUTE format('UPDATE %I SET deleted_at = NULL WHERE deleted_at = ''''', r.table_name);
+    BEGIN
+      EXECUTE format('UPDATE %I SET deleted_at = NULL WHERE deleted_at = ''''', r.table_name);
+    EXCEPTION WHEN others THEN
+      RAISE WARNING 'lattice: skipped deleted_at normalization for %: %', r.table_name, SQLERRM;
+    END;
   END LOOP;
 END $LATTICE_DAU$;`
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "latticesql",
-  "version": "4.3.5",
+  "version": "4.3.7",
   "description": "Persistent structured memory for AI agent systems — pluggable SQLite or Postgres backend, LLM context bridge",
   "type": "module",
   "main": "./dist/index.js",