latticesql 1.9.0 → 1.10.0

package/README.md

@@ -77,10 +77,10 @@ npm install latticesql
 
 Requires **Node.js 18+**. The default backend is SQLite (`better-sqlite3`) — no external database process needed.
 
-To use the Postgres backend (for Supabase, Neon, RDS, or any other Postgres-compatible database), install the optional dependencies:
+To use the Postgres backend (for Supabase, Neon, RDS, or any other Postgres-compatible database), install the optional dependency:
 
 ```bash
-npm install latticesql pg synckit
+npm install latticesql pg
 ```
 
 Then pass a connection string instead of a file path:
@@ -2153,12 +2153,14 @@ The rest of the API — `define()`, `init()`, `query()`, `insert()`, `render()`,
 
 ### Postgres setup
 
-`PostgresAdapter` depends on `pg` and `synckit`. Both are listed as `optionalDependencies`, so SQLite-only consumers don't pay the install cost. Install them when you actually use Postgres:
+`PostgresAdapter` depends on `pg`, listed as an `optionalDependency` so SQLite-only consumers don't pay the install cost. Install it when you actually use Postgres:
 
 ```bash
-npm install pg synckit
+npm install pg
 ```
 
+> **Migrating from `<= 1.9.x`?** `synckit` is no longer a dependency. Drop it from your install. The `dist/postgres-worker.cjs` file is also gone (it served the now-removed sync surface).
+
 Then point Lattice at any Postgres-compatible database that speaks the standard wire protocol on port 5432:
 
 ```ts
@@ -2166,16 +2168,13 @@ const lattice = new Lattice('postgres://user:pass@host:5432/db');
 await lattice.init();
 ```
 
-**Connection pooler note:** the `PostgresAdapter` exposes both a synckit-bridged sync surface and a native `pg.Pool`-backed async surface (since 1.8.0). Pick your pooler endpoint based on which surface you primarily use:
-
-- **Transaction-mode pooling** (e.g. PgBouncer transaction-mode, Supabase port `6543`) — recommended for `pg.Pool`-backed callers. The async surface (`runAsync`/`getAsync`/`allAsync`/`withClient`) is designed for transaction-mode: server-side prepared statements aren't kept across calls (because the upstream connection returns to the pool at `COMMIT`), and `prepareAsync` re-binds per call, so the prepared-statement-incompatibility caveat doesn't apply. Migrations are wrapped in `withClient(fn)` and acquire a transaction-scoped advisory lock so concurrent app boots serialize cleanly.
-- **Session-mode pooling** (e.g. PgBouncer session-mode, Supabase port `5432`) — required if you rely on the synckit-bridged sync surface (`adapter.run`/`adapter.prepare`) for transactional code. The synckit worker owns a single `pg.Client`, so session-mode preserves the per-connection guarantees that raw `BEGIN`/`COMMIT` calls assume.
+**Recommended pooler:** **transaction-mode** (e.g. PgBouncer transaction-mode, Supabase port `6543`). `PostgresAdapter` is native against `pg.Pool` and designed for transaction-mode: server-side prepared statements aren't kept across calls (because the upstream connection returns to the pool at `COMMIT`), and `prepareAsync` re-binds per call. Migrations are wrapped in `withClient(fn)` and acquire a transaction-scoped advisory lock so concurrent app boots serialize cleanly. `pool.max` is configurable via `PostgresAdapterOptions.poolSize` (default 10).
 
-**Two surfaces, one adapter (since 1.8.0):**
+**Async-only on Postgres (since 1.10.0):**
 
-- **Sync surface** (`run` / `get` / `all` / `prepare`) — bridged via a synckit worker thread that owns a single `pg.Client`. The main thread blocks on `Atomics.wait` until the worker replies. Each query pays ~1–3 ms of message-passing overhead. Preserved for back-compat with third-party adapters that don't implement the async surface; lattice itself no longer uses it on the hot path.
-- **Async surface** (`runAsync` / `getAsync` / `allAsync` / `prepareAsync` / `withClient`) — native against a `pg.Pool` in the main thread. No synckit, no `Atomics.wait`. The Node event loop is free to handle other work between awaited DB roundtrips. **Since 1.9.0, lattice core internally prefers this surface at every call site** when the configured adapter implements it (Postgres) — fall-back to the sync surface only when the adapter doesn't expose async methods (SQLite). `pool.max` is configurable via `PostgresAdapterOptions.poolSize` (default 10).
-- **Transactional contract**: any code that issues `BEGIN`/`COMMIT` should use `withClient(fn)` rather than raw `adapter.run('BEGIN')`. The pool checks out a single connection for the lifetime of `fn` and the `TxClient` handed to `fn` pins every query to that connection. Raw `adapter.run('BEGIN')` is only safe under the synckit worker (single-connection by construction); the next major release will remove the synckit worker entirely.
+- The async surface (`runAsync` / `getAsync` / `allAsync` / `prepareAsync` / `introspectColumnsAsync` / `addColumnAsync` / `withClient`) is the *only* path that does work against Postgres. The synchronous methods (`run` / `get` / `all` / `prepare` / `introspectColumns` / `addColumn`) **throw** with a clear error pointing at the async equivalent. `pg.Pool` is fundamentally async; the previous synckit-bridged sync surface was a workaround that blocked the Node main thread on `Atomics.wait`, and it was removed in 1.10.0 once lattice core had migrated to async at every call site (1.9.0).
+- `SQLiteAdapter` keeps the sync surface as the authoritative path (better-sqlite3 is sync by design). Its async methods just wrap the sync calls in resolved Promises — the one-microtask cost is negligible relative to having a single cross-dialect code path.
+- **Transactional contract**: any code that issues `BEGIN`/`COMMIT` should use `withClient(fn)`. The pool checks out a single connection for the lifetime of `fn` and the `TxClient` handed to `fn` pins every query to that connection. Raw `adapter.runAsync('BEGIN')` is unsafe — different awaited calls land on different upstream connections under transaction-mode pooling.
 
 ```ts
 // Recommended pattern for transactional writes
@@ -2202,7 +2201,9 @@ export interface StorageAdapter {
   // core. Most application code never needs to read this.
   readonly dialect: 'sqlite' | 'postgres';
 
-  // Sync surface — required.
+  // Sync surface — required by the interface. Sync-native backends like
+  // SQLite implement it; async-native backends like Postgres (since 1.10.0)
+  // throw with a helpful error pointing callers at the async equivalents.
   run(sql: string, params?: unknown[]): void;
   get(sql: string, params?: unknown[]): Row | undefined;
   all(sql: string, params?: unknown[]): Row[];
@@ -2217,6 +2218,8 @@ export interface StorageAdapter {
   getAsync?(sql: string, params?: unknown[]): Promise<Row | undefined>;
   allAsync?(sql: string, params?: unknown[]): Promise<Row[]>;
   prepareAsync?(sql: string): PreparedStatementAsync;
+  introspectColumnsAsync?(table: string): Promise<string[]>;
+  addColumnAsync?(table: string, column: string, typeSpec: string): Promise<void>;
   withClient?<T>(fn: (tx: TxClient) => Promise<T>): Promise<T>;
 }
 ```

package/dist/cli.js

@@ -415,6 +415,16 @@ async function getAsyncOrSync(adapter, sql, params) {
 async function allAsyncOrSync(adapter, sql, params) {
   return adapter.allAsync ? adapter.allAsync(sql, params) : adapter.all(sql, params);
 }
+async function introspectColumnsAsyncOrSync(adapter, table) {
+  return adapter.introspectColumnsAsync ? adapter.introspectColumnsAsync(table) : adapter.introspectColumns(table);
+}
+async function addColumnAsyncOrSync(adapter, table, column, typeSpec) {
+  if (adapter.addColumnAsync) {
+    await adapter.addColumnAsync(table, column, typeSpec);
+  } else {
+    adapter.addColumn(table, column, typeSpec);
+  }
+}
 
 // src/db/sqlite.ts
 import Database from "better-sqlite3";
@@ -483,6 +493,26 @@ var SQLiteAdapter = class {
       this.run(`ALTER TABLE "${table}" ADD COLUMN "${column}" ${typeSpec}`);
     }
   }
+  // ── Async surface ───────────────────────────────────────────────────
+  // SQLite is fundamentally synchronous (better-sqlite3 by design), so the
+  // async methods just wrap the sync versions in resolved Promises. They
+  // exist so callers can write a single async-preferring code path that
+  // works against both backends without branching on dialect.
+  async runAsync(sql, params) {
+    this.run(sql, params);
+  }
+  async getAsync(sql, params) {
+    return this.get(sql, params);
+  }
+  async allAsync(sql, params) {
+    return this.all(sql, params);
+  }
+  async introspectColumnsAsync(table) {
+    return this.introspectColumns(table);
+  }
+  async addColumnAsync(table, column, typeSpec) {
+    this.addColumn(table, column, typeSpec);
+  }
   /**
    * Run `fn` inside a BEGIN/COMMIT block on the single SQLite connection.
    * The TxClient surface delegates to the same underlying database as the
@@ -547,30 +577,21 @@ function moduleContext() {
   }
   return _moduleContext;
 }
+var SYNC_NOT_SUPPORTED_MSG = "PostgresAdapter: synchronous adapter methods (run/get/all/prepare/introspectColumns/addColumn) are no longer supported on Postgres as of latticesql 1.10.0. Use the async surface (runAsync/getAsync/allAsync/prepareAsync/introspectColumnsAsync/addColumnAsync/withClient) instead. Lattice core methods (Lattice.query, .insert, .update, .render, etc.) already route through the async surface \u2014 only consumer code that escapes into adapter.run/get/all directly needs migrating.";
 var PostgresAdapter = class {
   dialect = "postgres";
   _connectionString;
-  _workerPath;
   _poolSize;
-  _syncFn = null;
   _pool = null;
+  _polyfillsReady = null;
   _opened = false;
   constructor(connectionString, options = {}) {
     this._connectionString = connectionString;
-    this._workerPath = options.workerPath ?? path.join(moduleContext().dir, "postgres-worker.cjs");
     this._poolSize = options.poolSize ?? 10;
   }
   open() {
     if (this._opened) return;
     const ctxRequire = moduleContext().require;
-    let createSyncFn;
-    try {
-      ({ createSyncFn } = ctxRequire("synckit"));
-    } catch (err) {
-      throw new Error(
-        "PostgresAdapter requires 'synckit'. Install with: npm install synckit\nUnderlying error: " + (err instanceof Error ? err.message : String(err))
-      );
-    }
     let pgMod;
     try {
       pgMod = ctxRequire("pg");
@@ -579,75 +600,62 @@ var PostgresAdapter = class {
         "PostgresAdapter requires 'pg'. Install with: npm install pg\nUnderlying error: " + (err instanceof Error ? err.message : String(err))
       );
     }
-    this._syncFn = createSyncFn(this._workerPath);
-    this._call({ type: "open", connectionString: this._connectionString });
     this._pool = new pgMod.Pool({
       connectionString: this._connectionString,
       max: this._poolSize
     });
+    this._polyfillsReady = this._registerPolyfills();
     this._opened = true;
   }
   close() {
     if (!this._opened) return;
-    this._call({ type: "close" });
     if (this._pool) {
       void this._pool.end().catch(() => {
       });
       this._pool = null;
     }
+    this._polyfillsReady = null;
     this._opened = false;
-    this._syncFn = null;
   }
-  run(sql, params = []) {
-    this._call({ type: "run", sql: rewrite(sql), params });
+  // ── Sync surface (no longer supported on Postgres) ──────────────────
+  // The synchronous methods on StorageAdapter exist for SQLite consumers
+  // (better-sqlite3 is sync by design). On Postgres they throw — `pg.Pool`
+  // is fundamentally async and the synckit-bridged sync path was removed
+  // in 1.10.0 to drop the `Atomics.wait` blocking it imposed on the Node
+  // main thread.
+  run(_sql, _params = []) {
+    throw new Error(SYNC_NOT_SUPPORTED_MSG);
   }
-  get(sql, params = []) {
-    const r = this._call({ type: "get", sql: rewrite(sql), params });
-    return r.rows?.[0];
+  get(_sql, _params = []) {
+    throw new Error(SYNC_NOT_SUPPORTED_MSG);
   }
-  all(sql, params = []) {
-    const r = this._call({ type: "all", sql: rewrite(sql), params });
-    return r.rows ?? [];
+  all(_sql, _params = []) {
+    throw new Error(SYNC_NOT_SUPPORTED_MSG);
   }
-  prepare(sql) {
-    const rewritten = rewrite(sql);
-    return {
-      run: (...params) => {
-        const r = this._call({ type: "run", sql: rewritten, params });
-        return { changes: r.rowCount ?? 0, lastInsertRowid: 0 };
-      },
-      get: (...params) => {
-        const r = this._call({ type: "get", sql: rewritten, params });
-        return r.rows?.[0];
-      },
-      all: (...params) => {
-        const r = this._call({ type: "all", sql: rewritten, params });
-        return r.rows ?? [];
-      }
-    };
+  prepare(_sql) {
+    throw new Error(SYNC_NOT_SUPPORTED_MSG);
   }
-  introspectColumns(table) {
-    const r = this._call({ type: "introspectColumns", table });
-    return (r.rows ?? []).map((row) => row.column_name);
+  introspectColumns(_table) {
+    throw new Error(SYNC_NOT_SUPPORTED_MSG);
   }
-  addColumn(table, column, typeSpec) {
-    this._call({ type: "addColumn", table, column, typeSpec });
+  addColumn(_table, _column, _typeSpec) {
+    throw new Error(SYNC_NOT_SUPPORTED_MSG);
   }
   // ── Async surface ───────────────────────────────────────────────────
-  // Native against pg.Pool. No synckit, no Atomics.wait. The Node event
-  // loop is free to handle other work (HTTP requests, Slack socket pings,
-  // scheduler timers, etc.) while these calls await DB I/O.
+  // Native against pg.Pool. The Node event loop is free to handle other
+  // work (HTTP requests, Slack socket pings, scheduler timers, etc.) while
+  // these calls await DB I/O.
   async runAsync(sql, params = []) {
-    const pool = this._requirePool();
+    const pool = await this._readyPool();
     await pool.query(rewrite(sql), params);
   }
   async getAsync(sql, params = []) {
-    const pool = this._requirePool();
+    const pool = await this._readyPool();
     const r = await pool.query(rewrite(sql), params);
     return r.rows[0];
   }
   async allAsync(sql, params = []) {
-    const pool = this._requirePool();
+    const pool = await this._readyPool();
     const r = await pool.query(rewrite(sql), params);
     return r.rows;
   }
@@ -669,22 +677,41 @@ var PostgresAdapter = class {
     const rewritten = rewrite(sql);
     return {
       run: async (...params) => {
-        const pool = this._requirePool();
+        const pool = await this._readyPool();
         const r = await pool.query(rewritten, params);
         return { changes: r.rowCount ?? 0, lastInsertRowid: 0 };
       },
       get: async (...params) => {
-        const pool = this._requirePool();
+        const pool = await this._readyPool();
         const r = await pool.query(rewritten, params);
         return r.rows[0];
       },
       all: async (...params) => {
-        const pool = this._requirePool();
+        const pool = await this._readyPool();
         const r = await pool.query(rewritten, params);
         return r.rows;
       }
     };
   }
+  async introspectColumnsAsync(table) {
+    const pool = await this._readyPool();
+    const r = await pool.query(
+      `SELECT column_name FROM information_schema.columns
+       WHERE table_schema = current_schema() AND table_name = $1
+       ORDER BY ordinal_position`,
+      [table]
+    );
+    return r.rows.map((row) => row.column_name);
+  }
+  async addColumnAsync(table, column, typeSpec) {
+    const upper = typeSpec.toUpperCase();
+    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}`
+    );
+  }
   /**
    * Run `fn` against a single checked-out pool client wrapped in BEGIN/COMMIT.
    * The TxClient handed to `fn` runs every query against the same upstream
@@ -697,7 +724,7 @@ var PostgresAdapter = class {
    * the connection rather than recycling a known-bad one.
    */
   async withClient(fn) {
-    const pool = this._requirePool();
+    const pool = await this._readyPool();
     const client = await pool.connect();
     const tx = {
       run: async (sql, params) => {
@@ -732,19 +759,96 @@ var PostgresAdapter = class {
       client.release(releaseErr);
     }
   }
-  _requirePool() {
+  /**
+   * Resolve the pool, waiting for one-time polyfill registration to complete.
+   * Every async method funnels through here so the polyfills are guaranteed
+   * to be in place by the time the caller's first query runs.
+   */
+  async _readyPool() {
     if (!this._pool) {
       throw new Error("PostgresAdapter: not open \u2014 call open() first");
     }
+    if (this._polyfillsReady) await this._polyfillsReady;
     return this._pool;
   }
-  _call(action) {
-    if (!this._syncFn) throw new Error("PostgresAdapter: not open \u2014 call open() first");
-    const result = this._syncFn(action);
-    if (!result.ok) {
-      throw new Error(`PostgresAdapter: ${result.error}`);
+  /**
+   * Idempotently register the SQLite-compat polyfills the dialect translator
+   * relies on:
+   *   - `pgcrypto` extension — provides `gen_random_bytes()` for the
+   *     `randomblob()` translation.
+   *   - `json_extract(doc, path)` SQL function — mimics SQLite's
+   *     `$.a.b.c` path syntax against jsonb.
+   *   - `strftime(format, modifier)` SQL function — handles the common
+   *     `strftime('%Y-%m-%dT%H:%M:%fZ', 'now')` pattern lattice itself emits
+   *     for ISO timestamps.
+   *
+   * Each registration is wrapped in try/catch so a permission-restricted
+   * provider (e.g. some managed Postgres tiers don't allow CREATE EXTENSION)
+   * surfaces a non-fatal warning rather than blocking pool readiness.
+   */
+  async _registerPolyfills() {
+    if (!this._pool) return;
+    const pool = this._pool;
+    try {
+      await pool.query("CREATE EXTENSION IF NOT EXISTS pgcrypto");
+    } catch (extErr) {
+      console.warn(
+        "[PostgresAdapter] CREATE EXTENSION pgcrypto failed (may already be enabled by your provider):",
+        extErr instanceof Error ? extErr.message : extErr
+      );
+    }
+    try {
+      await pool.query(
+        `CREATE OR REPLACE FUNCTION json_extract(doc text, path text)
+         RETURNS text
+         LANGUAGE sql
+         IMMUTABLE
+         AS $fn$
+           SELECT doc::jsonb #>> string_to_array(regexp_replace(path, '^\\$\\.?', ''), '.')
+         $fn$;`
+      );
+    } catch (jeErr) {
+      console.warn(
+        "[PostgresAdapter] could not register json_extract polyfill:",
+        jeErr instanceof Error ? jeErr.message : jeErr
+      );
+    }
+    try {
+      await pool.query(
+        `CREATE OR REPLACE FUNCTION strftime(format text, modifier text)
+         RETURNS text
+         LANGUAGE plpgsql
+         IMMUTABLE
+         AS $fn$
+         DECLARE ts timestamptz;
+         BEGIN
+           IF modifier = 'now' THEN
+             ts := now();
+           ELSE
+             ts := modifier::timestamptz;
+           END IF;
+           RETURN to_char(
+             ts AT TIME ZONE 'UTC',
+             replace(replace(replace(replace(replace(replace(replace(replace(
+               format,
+               '%Y', 'YYYY'),
+               '%m', 'MM'),
+               '%d', 'DD'),
+               '%H', 'HH24'),
+               '%M', 'MI'),
+               '%S', 'SS'),
+               '%f', 'MS'),
+               'T', '"T"')
+           );
+         END;
+         $fn$;`
+      );
+    } catch (sfErr) {
+      console.warn(
+        "[PostgresAdapter] could not register strftime polyfill:",
+        sfErr instanceof Error ? sfErr.message : sfErr
+      );
     }
-    return result;
   }
 };
 function translateDialect(sql) {
@@ -780,6 +884,9 @@ function translateDialect(sql) {
   });
   return s;
 }
+function translateTypeSpec(typeSpec) {
+  return typeSpec.replace(/\bBLOB\b/gi, "BYTEA").replace(/\bdatetime\(\s*'now'\s*\)/gi, "NOW()").replace(/\bRANDOM\(\)/gi, "random()");
+}
 function hasOnConflictInCode(sql) {
   let found = false;
   mapCodeRegions(sql, (code) => {
@@ -1166,7 +1273,7 @@ var SchemaManager = class {
       return allAsyncOrSync(adapter, `SELECT * FROM "${name}"`);
     }
     if (this._entityContexts.has(name)) {
-      const cols = adapter.introspectColumns(name);
+      const cols = await introspectColumnsAsyncOrSync(adapter, name);
       const hasDeletedAt = cols.includes("deleted_at");
       return allAsyncOrSync(
         adapter,
@@ -1182,13 +1289,13 @@ var SchemaManager = class {
       adapter,
       `CREATE TABLE IF NOT EXISTS "${name}" (${colDefs}${constraintDefs})`
     );
-    this._addMissingColumns(adapter, name, columns);
+    await this._addMissingColumns(adapter, name, columns);
   }
-  _addMissingColumns(adapter, table, columns) {
-    const existing = adapter.introspectColumns(table);
+  async _addMissingColumns(adapter, table, columns) {
+    const existing = await introspectColumnsAsyncOrSync(adapter, table);
     for (const [col, type] of Object.entries(columns)) {
       if (existing.includes(col)) continue;
-      adapter.addColumn(table, col, type);
+      await addColumnAsyncOrSync(adapter, table, col, type);
     }
   }
 };
@@ -2472,7 +2579,7 @@ var ReverseSeedEngine = class {
    * and the "did the insert actually add a row" check would be racy.
    */
   async _insertOrIgnore(tx, table, row) {
-    const validColumns = new Set(this._adapter.introspectColumns(table));
+    const validColumns = new Set(await introspectColumnsAsyncOrSync(this._adapter, table));
     const filtered = {};
     for (const [key, val] of Object.entries(row)) {
       if (validColumns.has(key)) {
@@ -3033,9 +3140,10 @@ var Lattice = class {
       await this._schema.applyMigrationsAsync(this._adapter, options.migrations);
     }
     for (const tableName of this._schema.getTables().keys()) {
-      this._columnCache.set(tableName, new Set(this._adapter.introspectColumns(tableName)));
+      const cols = await introspectColumnsAsyncOrSync(this._adapter, tableName);
+      this._columnCache.set(tableName, new Set(cols));
     }
-    this._finalizeEncryptionSetup();
+    await this._finalizeEncryptionSetup();
     const hasEmbeddings = [...this._schema.getTables().values()].some((d) => d.embeddings);
     if (hasEmbeddings) {
       await ensureEmbeddingsTable(this._adapter);
@@ -3058,7 +3166,8 @@ var Lattice = class {
     }
     await this._schema.applyMigrationsAsync(this._adapter, migrations);
     for (const tableName of this._schema.getTables().keys()) {
-      this._columnCache.set(tableName, new Set(this._adapter.introspectColumns(tableName)));
+      const cols = await introspectColumnsAsyncOrSync(this._adapter, tableName);
+      this._columnCache.set(tableName, new Set(cols));
     }
   }
   close() {
@@ -3109,12 +3218,12 @@ var Lattice = class {
    * see the post-migration schema. Runs in the async tail of init() after
    * applySchema/applyMigrationsAsync.
    */
-  _finalizeEncryptionSetup() {
+  async _finalizeEncryptionSetup() {
     for (const [table, def] of this._schema.getEntityContexts()) {
       if (!def.encrypted) continue;
       if (!this._encryptionKeyRaw) continue;
       this._encryptionKey ??= deriveKey(this._encryptionKeyRaw);
-      const allCols = this._adapter.introspectColumns(table);
+      const allCols = await introspectColumnsAsyncOrSync(this._adapter, table);
       const encCols = resolveEncryptedColumns(def.encrypted, allCols);
       this._encryptedTableColumns.set(table, encCols);
     }
@@ -3977,14 +4086,25 @@ var Lattice = class {
    * objects are interpolated into SQL, so stripping unknown keys eliminates
    * any theoretical injection vector from crafted object keys.
    */
-  /** Lazily populate column cache for tables not registered via define(). */
+  /**
+   * Return the column cache for a registered table. The cache is pre-populated
+   * for every `define()`d table at the end of `_initAsync` (after migrations
+   * apply, so migration-added columns are visible). Tables accessed through
+   * the raw `.db` / `.adapter` escape hatch — outside lattice's `define()`
+   * contract — return an empty set; their callers' `_filterToSchemaColumns`
+   * short-circuit ("unknown table — pass through") is the right behavior for
+   * those, since column filtering needs a known column list.
+   *
+   * Pre-1.10.0 this method had a lazy `introspectColumns` fallback for
+   * unregistered tables. The fallback was dropped when synckit was removed —
+   * synchronous Postgres introspection has no path on `pg.Pool`. The
+   * effective behavior change is: raw-.db writes to a table that lattice
+   * never `define()`d no longer get their `Row` filtered to "schema-known
+   * columns". That contract is preserved for every `define()`d table, which
+   * is what production code uses.
+   */
   _ensureColumnCache(table) {
-    let cols = this._columnCache.get(table);
-    if (!cols) {
-      cols = new Set(this._adapter.introspectColumns(table));
-      if (cols.size > 0) this._columnCache.set(table, cols);
-    }
-    return cols;
+    return this._columnCache.get(table) ?? /* @__PURE__ */ new Set();
   }
   _filterToSchemaColumns(table, row) {
     const cols = this._ensureColumnCache(table);