uql-orm 0.30.0 → 0.31.0

package/README.md

@@ -50,13 +50,13 @@ from the browser to the server. The same object runs on every supported database
 
 - **Serializable queries (JSON), not method chains.** Plain JSON in, typed rows out. No DSL to learn.
 - **Type-safe to the leaf, nothing to generate.** Every key is checked against your entity, down into populated relations and [JSON/JSONB](https://uql-orm.dev/querying/json) dot-paths, so `$like` on a numeric column is a compile error. Entities are plain classes on the standard TC39 decorators: no `.prisma` file, no generated client, no `reflect-metadata`, no `experimentalDecorators`.
-- **One API, everywhere it runs.** PostgreSQL, CockroachDB, MySQL, MariaDB, SQLite, Turso, libSQL, Neon, Cloudflare D1, Bun's native SQL, and even MongoDB. The same code on Node 24+, Bun, Deno, [Cloudflare Workers](https://uql-orm.dev/cloudflare-d1), [AWS Lambda and Vercel](https://uql-orm.dev/serverless), and [the browser](https://uql-orm.dev/browser), with no native binaries on the `fetch`-based drivers.
+- **One API, everywhere it runs.** PostgreSQL, PGlite, CockroachDB, MySQL, MariaDB, SQLite, Turso, libSQL, Neon, Cloudflare D1, Bun's native SQL, and even MongoDB. The same code on Node 24+, Bun, Deno, [Cloudflare Workers](https://uql-orm.dev/cloudflare-d1), [AWS Lambda and Vercel](https://uql-orm.dev/serverless), and [the browser](https://uql-orm.dev/browser), with no native binaries on the `fetch`-based drivers.
 - **Relations without N+1.** [`$populate`](https://uql-orm.dev/querying/relations) loads a to-many with one query for all parents, not one per parent. Nothing is lazy, so nothing fires behind your back in a serializer.
 - **Migrations you read before they run.** Edit an entity, run `uql-migrate generate:entities`, review the SQL in the PR like any other file. [`drift:check`](https://uql-orm.dev/migrations) catches a database that no longer matches.
 - **Raw SQL when you want it.** [`raw()`](https://uql-orm.dev/querying/raw-sql) fits anywhere in a query, [virtual fields](https://uql-orm.dev/entities/virtual-fields) are sub-queries you can filter on, and a migration can be plain SQL.
 - **Light.** Zero runtime dependencies, under 280 kB on the wire, every dialect included. See [what we deleted to get there](https://uql-orm.dev/blog/zero-dependencies).
 - **The hard things are built in.** [Semantic and vector search](https://uql-orm.dev/ai-semantic-search), [multi-tenant filters you cannot bypass by accident](https://uql-orm.dev/multi-tenancy), [soft-delete with restore](https://uql-orm.dev/entities/soft-delete), [streaming](https://uql-orm.dev/querying/streaming), and [a REST API from your entities](https://uql-orm.dev/http).
-- **The fastest ORM.** On a full PostgreSQL round trip it adds the least over hand-written driver code of any ORM in our open-source [benchmark](https://github.com/rogerpadilla/ts-orm-benchmark), by roughly 3x over the next closest and an order of magnitude over the slowest.
+- **The fastest ORM.** On a full PostgreSQL round trip it adds the least over hand-written driver code of any ORM in our open-source [benchmark](https://github.com/rogerpadilla/ts-orm-benchmark), by roughly 3x over the next closest and an order of magnitude over the slowest, on Bun, Node and Deno alike.
 
 ## Get started
 
@@ -71,8 +71,16 @@ Release notes live in [CHANGELOG.md](https://github.com/rogerpadilla/uql/blob/ma
 
 ## Made with UQL
 
-**[Variability.ai](https://variability.ai)** - AI meeting recorder and video summarizer for Zoom, Meet, and Teams. Instant summaries with action items in 45+ languages.
+**[Variability.ai](https://variability.ai)** - AI meeting recorder and video summarizer for Zoom, Meet, and Teams. Instant summaries with action items in 35+ languages.
 
 Built something? [Open a PR](https://github.com/rogerpadilla/uql/blob/main/CONTRIBUTING.md) and add it here.
 
 [![Made with UQL](https://img.shields.io/badge/made%20with-UQL-3282b5?style=flat)](https://uql-orm.dev)
+
+---
+
+## ⭐ Like what we're doing? Give us a star
+
+It is how other people find the project.
+
+[![Star UQL on GitHub](https://img.shields.io/github/stars/rogerpadilla/uql?style=flat&label=stars&color=3282b5)](https://github.com/rogerpadilla/uql)

package/dist/browser/uql-browser.min.js

@@ -1,4 +1,4 @@
-var d=[];function a(e){for(let n of d)n(e)}function k(e){d.push(e);let n=d.length-1;return()=>{d.splice(n,1)}}class m extends Error{status;constructor(e,n){super(e);this.status=n;this.name="RequestError"}}function y(e,n){return i(e,{method:"get"},n)}function f(e,n,t){let r=JSON.stringify(n);return i(e,{method:"post",body:r},t)}function l(e,n,t){let r=JSON.stringify(n);return i(e,{method:"patch",body:r},t)}function E(e,n,t){let r=JSON.stringify(n);return i(e,{method:"put",body:r},t)}function g(e,n){return i(e,{method:"delete"},n)}function T(e,n,t){let r=JSON.stringify(n);return i(e,{method:"QUERY",body:r},t)}function i(e,n,t){if(a({phase:"start",opts:t}),n.headers={accept:"application/json","content-type":"application/json",...t?.headers},t?.signal)n.signal=t.signal;return fetch(e,n).then((r)=>r.json().then((s)=>{if(r.status>=200&&r.status<300)return a({phase:"success",opts:t}),s;let O=s,h={message:O?.error?.message??r.statusText,code:O?.error?.code??r.status};throw a({phase:"error",error:h,opts:t}),new m(h.message,h.code)})).finally(()=>{a({phase:"complete",opts:t})})}function c(e){return e?Object.keys(e):[]}function b(e){let n=e.charAt(0).toLowerCase();for(let t=1;t<e.length;++t)n+=e[t]===e[t].toUpperCase()?"-"+e[t].toLowerCase():e[t];return n}var o={findMany:{method:"GET",path:""},findOne:{method:"GET",path:"/one"},count:{method:"GET",path:"/count"},findOneById:{method:"GET",path:"/:id"},insertOne:{method:"POST",path:""},insertMany:{method:"POST",path:"/many"},saveOne:{method:"PUT",path:""},saveMany:{method:"PUT",path:"/many"},updateMany:{method:"PATCH",path:""},updateOneById:{method:"PATCH",path:"/:id"},deleteOneById:{method:"DELETE",path:"/:id"},deleteMany:{method:"DELETE",path:""}},Q=c(o),A=new Map(Q.filter((e)=>o[e].method==="GET"&&o[e].path!=="/:id").map((e)=>[o[e].path,e]));function x(e){return b(e.name)}var q=["$select","$populate","$exclude","$where","$sort"],K=new Set([...q,"$skip","$limit","hardDelete","count"]);function u(e){if(!e)return"";let n=new URLSearchParams;for(let r of c(e)){let s=e[r];if(s===void 0)continue;n.append(r,typeof s==="object"&&s!==null?JSON.stringify(s):String(s))}let t=n.toString();return t?`?${t}`:""}class R{basePath;defaults;constructor(e,n={}){this.basePath=e;this.defaults=n}findOneById(e,n,t,r){let s=this.getBasePath(e),p=u(t);return y(`${s}/${n}${p}`,this.buildOptions(r))}findOne(e,n,t){return this.read(`${this.getBasePath(e)}${o.findOne.path}`,n,t)}findMany(e,n,t){let r={...n};if(t?.count)r.count=!0;return this.read(this.getBasePath(e),r,t)}async findManyAndCount(e,n,t){let r=await this.findMany(e,n,{...t,count:!0});if(typeof r.count!=="number")throw TypeError("findManyAndCount response has an invalid count");return{...r,count:r.count}}count(e,n,t){return this.read(`${this.getBasePath(e)}${o.count.path}`,n,t)}insertOne(e,n,t){let r=this.getBasePath(e);return f(r,n,this.buildOptions(t))}insertMany(e,n,t){let r=this.getBasePath(e);return f(`${r}${o.insertMany.path}`,n,this.buildOptions(t))}updateOneById(e,n,t,r){let s=this.getBasePath(e);return l(`${s}/${n}`,t,this.buildOptions(r))}updateMany(e,n,t,r){let s=this.getBasePath(e),p=u(n);return l(`${s}${p}`,t,this.buildOptions(r))}saveOne(e,n,t){let r=this.getBasePath(e);return E(r,n,this.buildOptions(t))}saveMany(e,n,t){let r=this.getBasePath(e);return E(`${r}${o.saveMany.path}`,n,this.buildOptions(t))}deleteOneById(e,n,t={}){let r=this.getBasePath(e),s=t.hardDelete?u({hardDelete:t.hardDelete}):"";return g(`${r}/${n}${s}`,this.buildOptions(t))}deleteMany(e,n,t={}){let r=this.getBasePath(e),s=u(t.hardDelete?{...n,hardDelete:t.hardDelete}:n);return g(`${r}${s}`,this.buildOptions(t))}getBasePath(e){return`${this.basePath}/${x(e)}`}read(e,n,t){if(this.defaults.readMethod==="QUERY")return T(e,n??{},this.buildOptions(t));return y(`${e}${u(n)}`,this.buildOptions(t))}buildOptions(e){if(!this.defaults.headers&&!e?.headers)return e;return{...e,headers:{...this.defaults.headers,...e?.headers}}}}var P={getQuerier:()=>new R("/api")};function J(e){P=e}function C(){return P}function V(){return C().getQuerier()}export{R as HttpQuerier,m as RequestError,y as get,V as getQuerier,C as getQuerierPool,a as notify,k as on,l as patch,f as post,E as put,T as query,g as remove,J as setQuerierPool};
+var W=[];function F(B){for(let V of W)V(B)}function _(B){W.push(B);let V=W.length-1;return()=>{W.splice(V,1)}}class f extends Error{status;constructor(B,V){super(B);this.status=V;this.name="RequestError"}}function N(B,V){return G(B,{method:"get"},V)}function Q(B,V,I){let X=JSON.stringify(V);return G(B,{method:"post",body:X},I)}function J(B,V,I){let X=JSON.stringify(V);return G(B,{method:"patch",body:X},I)}function L(B,V,I){let X=JSON.stringify(V);return G(B,{method:"put",body:X},I)}function x(B,V){return G(B,{method:"delete"},V)}function T(B,V,I){let X=JSON.stringify(V);return G(B,{method:"QUERY",body:X},I)}function G(B,V,I){if(F({phase:"start",opts:I}),V.headers={accept:"application/json","content-type":"application/json",...I?.headers},I?.signal)V.signal=I.signal;return fetch(B,V).then((X)=>X.json().then((Z)=>{if(X.status>=200&&X.status<300)return F({phase:"success",opts:I}),Z;let Y=Z,M={message:Y?.error?.message??X.statusText,code:Y?.error?.code??X.status};throw F({phase:"error",error:M,opts:I}),new f(M.message,M.code)})).finally(()=>{F({phase:"complete",opts:I})})}function z(B){return B?Object.keys(B):[]}function K(B){let V=B.charAt(0).toLowerCase();for(let I=1;I<B.length;++I)V+=B[I]===B[I].toUpperCase()?"-"+B[I].toLowerCase():B[I];return V}var $={findMany:{method:"GET",path:""},findOne:{method:"GET",path:"/one"},count:{method:"GET",path:"/count"},findOneById:{method:"GET",path:"/:id"},insertOne:{method:"POST",path:""},insertMany:{method:"POST",path:"/many"},saveOne:{method:"PUT",path:""},saveMany:{method:"PUT",path:"/many"},updateMany:{method:"PATCH",path:""},updateOneById:{method:"PATCH",path:"/:id"},deleteOneById:{method:"DELETE",path:"/:id"},deleteMany:{method:"DELETE",path:""}},k=z($),b=new Map(k.filter((B)=>$[B].method==="GET"&&$[B].path!=="/:id").map((B)=>[$[B].path,B]));function D(B){return K(B.name)}var c=["$select","$populate","$exclude","$where","$sort"],v=new Set([...c,"$skip","$limit","hardDelete","count"]);function A(B){if(!B)return"";let V=new URLSearchParams;for(let X of z(B)){let Z=B[X];if(Z===void 0)continue;V.append(X,typeof Z==="object"&&Z!==null?JSON.stringify(Z):String(Z))}let I=V.toString();return I?`?${I}`:""}class C{basePath;defaults;constructor(B,V={}){this.basePath=B;this.defaults=V}findOneById(B,V,I,X){let Z=this.getBasePath(B),H=A(I);return N(`${Z}/${V}${H}`,this.buildOptions(X))}findOne(B,V,I){return this.read(`${this.getBasePath(B)}${$.findOne.path}`,V,I)}findMany(B,V,I){let X={...V};if(I?.count)X.count=!0;return this.read(this.getBasePath(B),X,I)}async findManyAndCount(B,V,I){let X=await this.findMany(B,V,{...I,count:!0});if(typeof X.count!=="number")throw TypeError("findManyAndCount response has an invalid count");return{...X,count:X.count}}count(B,V,I){return this.read(`${this.getBasePath(B)}${$.count.path}`,V,I)}insertOne(B,V,I){let X=this.getBasePath(B);return Q(X,V,this.buildOptions(I))}insertMany(B,V,I){let X=this.getBasePath(B);return Q(`${X}${$.insertMany.path}`,V,this.buildOptions(I))}updateOneById(B,V,I,X){let Z=this.getBasePath(B);return J(`${Z}/${V}`,I,this.buildOptions(X))}updateMany(B,V,I,X){let Z=this.getBasePath(B),H=A(V);return J(`${Z}${H}`,I,this.buildOptions(X))}saveOne(B,V,I){let X=this.getBasePath(B);return L(X,V,this.buildOptions(I))}saveMany(B,V,I){let X=this.getBasePath(B);return L(`${X}${$.saveMany.path}`,V,this.buildOptions(I))}deleteOneById(B,V,I={}){let X=this.getBasePath(B),Z=I.hardDelete?A({hardDelete:I.hardDelete}):"";return x(`${X}/${V}${Z}`,this.buildOptions(I))}deleteMany(B,V,I={}){let X=this.getBasePath(B),Z=A(I.hardDelete?{...V,hardDelete:I.hardDelete}:V);return x(`${X}${Z}`,this.buildOptions(I))}getBasePath(B){return`${this.basePath}/${D(B)}`}read(B,V,I){if(this.defaults.readMethod==="QUERY")return T(B,V??{},this.buildOptions(I));return N(`${B}${A(V)}`,this.buildOptions(I))}buildOptions(B){if(!this.defaults.headers&&!B?.headers)return B;return{...B,headers:{...this.defaults.headers,...B?.headers}}}}var P={getQuerier:()=>new C("/api")};function y(B){P=B}function g(){return P}function p(){return g().getQuerier()}export{y as setQuerierPool,x as remove,T as query,L as put,Q as post,J as patch,_ as on,F as notify,g as getQuerierPool,p as getQuerier,N as get,f as RequestError,C as HttpQuerier};
 
-//# debugId=E55D2B69C2EDA86C64756E2164756E21
+//# debugId=63F5785EAD0E521C64756E2164756E21
 //# sourceMappingURL=uql-browser.min.js.map

package/dist/browser/uql-browser.min.js.map

@@ -12,6 +12,6 @@
     "import { HttpQuerier } from './querier/httpQuerier.js';\nimport type { ClientQuerier, ClientQuerierPool } from './type/index.js';\n\nlet defaultPool: ClientQuerierPool = {\n  getQuerier: () => new HttpQuerier('/api'),\n};\n\nexport function setQuerierPool<T extends ClientQuerierPool>(pool: T) {\n  defaultPool = pool;\n}\n\nexport function getQuerierPool(): ClientQuerierPool {\n  return defaultPool;\n}\n\nexport function getQuerier(): ClientQuerier {\n  return getQuerierPool().getQuerier();\n}\n"
   ],
   "mappings": "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",
-  "debugId": "E55D2B69C2EDA86C64756E2164756E21",
+  "debugId": "63F5785EAD0E521C64756E2164756E21",
   "names": []
 }

package/dist/pglite/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pgliteDialect.js';
+export * from './pgliteQuerier.js';
+export * from './pgliteQuerierPool.js';

package/dist/pglite/index.js

@@ -0,0 +1,3 @@
+export * from './pgliteDialect.js';
+export * from './pgliteQuerier.js';
+export * from './pgliteQuerierPool.js';

package/dist/pglite/pgliteDialect.d.ts

@@ -0,0 +1,14 @@
+import { PostgresDialect } from '../postgres/postgresDialect.js';
+/**
+ * Postgres dialect for PGlite, the WASM Postgres build.
+ *
+ * @remarks Keeps every {@link PostgresDialect} default, `dialectName` included: PGlite *is* Postgres,
+ * so the introspector, schema generator and CLI must all resolve to the Postgres ones. Both driver
+ * capabilities are inherited deliberately rather than by omission. `nativeArrays: true` holds because
+ * PGlite registers an array serializer for every built-in array type at boot and resolves each
+ * parameter's type from a server-side `Describe` before binding; `explicitJsonCast: false` holds
+ * because `PgLikeSqlDialect` already emits `$n::jsonb`, which is what makes that `Describe` report
+ * JSONB and select PGlite's `JSON.stringify` serializer. A bare `$n` would bind `[object Object]`.
+ */
+export declare class PgliteDialect extends PostgresDialect {
+}

package/dist/pglite/pgliteDialect.js

@@ -0,0 +1,14 @@
+import { PostgresDialect } from '../postgres/postgresDialect.js';
+/**
+ * Postgres dialect for PGlite, the WASM Postgres build.
+ *
+ * @remarks Keeps every {@link PostgresDialect} default, `dialectName` included: PGlite *is* Postgres,
+ * so the introspector, schema generator and CLI must all resolve to the Postgres ones. Both driver
+ * capabilities are inherited deliberately rather than by omission. `nativeArrays: true` holds because
+ * PGlite registers an array serializer for every built-in array type at boot and resolves each
+ * parameter's type from a server-side `Describe` before binding; `explicitJsonCast: false` holds
+ * because `PgLikeSqlDialect` already emits `$n::jsonb`, which is what makes that `Describe` report
+ * JSONB and select PGlite's `JSON.stringify` serializer. A bare `$n` would bind `[object Object]`.
+ */
+export class PgliteDialect extends PostgresDialect {
+}

package/dist/pglite/pgliteQuerier.d.ts

@@ -0,0 +1,36 @@
+import { AbstractSqlQuerier } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+import type { PgliteDialect } from './pgliteDialect.js';
+/**
+ * Structural subset of the `@electric-sql/pglite` API actually used here, declared locally so this
+ * package does not couple its published types to a pre-1.0 dependency.
+ *
+ * @remarks This is what uql *consumes* from the driver, so it is two methods and stating them costs
+ * nothing. `PglitePoolOptions` is the opposite case and imports PGlite's own type: those options are
+ * the caller's input to the driver, so restating them would mean re-deriving its whole option surface
+ * and then casting at the `PGlite.create` call.
+ */
+export type PgliteDatabase = {
+    query<T>(query: string, params?: unknown[]): Promise<{
+        rows: T[];
+        affectedRows?: number;
+    }>;
+    close(): Promise<void>;
+};
+/**
+ * Querier for PGlite, Postgres compiled to WASM and run in this process.
+ *
+ * @remarks Extends {@link AbstractSqlQuerier} rather than `AbstractPgQuerier`, whose `internalStream`
+ * hands a `pg-query-stream` object to `query()`: PGlite has no cursor API, so streaming falls back to
+ * the base class buffering the whole result. `BEGIN`/`COMMIT` are plain statements on the single
+ * connection, leaving transactions to the base class.
+ */
+export declare class PgliteQuerier extends AbstractSqlQuerier {
+    readonly db: PgliteDatabase;
+    readonly extra?: ExtraOptions | undefined;
+    constructor(db: PgliteDatabase, dialect: PgliteDialect, extra?: ExtraOptions | undefined);
+    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
+    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
+    /** The handle belongs to the pool, which hands out one querier per unit of work over it. */
+    internalRelease(): Promise<void>;
+}

package/dist/pglite/pgliteQuerier.js

@@ -0,0 +1,30 @@
+import { AbstractSqlQuerier } from '../querier/index.js';
+/**
+ * Querier for PGlite, Postgres compiled to WASM and run in this process.
+ *
+ * @remarks Extends {@link AbstractSqlQuerier} rather than `AbstractPgQuerier`, whose `internalStream`
+ * hands a `pg-query-stream` object to `query()`: PGlite has no cursor API, so streaming falls back to
+ * the base class buffering the whole result. `BEGIN`/`COMMIT` are plain statements on the single
+ * connection, leaving transactions to the base class.
+ */
+export class PgliteQuerier extends AbstractSqlQuerier {
+    db;
+    extra;
+    constructor(db, dialect, extra) {
+        super(dialect, extra);
+        this.db = db;
+        this.extra = extra;
+    }
+    async internalAll(query, values) {
+        const res = await this.db.query(query, values);
+        return res.rows;
+    }
+    async internalRun(query, values) {
+        const res = await this.db.query(query, values);
+        // `affectedRows`, not `rowCount`: PGlite derives the former from the command tag of a write only,
+        // where the latter also counts a `SELECT`'s rows and is absent altogether from a DDL tag.
+        return this.buildUpdateResult({ rows: res.rows, changes: res.affectedRows ?? 0 });
+    }
+    /** The handle belongs to the pool, which hands out one querier per unit of work over it. */
+    async internalRelease() { }
+}

package/dist/pglite/pgliteQuerierPool.d.ts

@@ -0,0 +1,36 @@
+import type { PGliteOptions } from '@electric-sql/pglite';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
+import type { ExtraOptions } from '../type/index.js';
+import { PgliteDialect } from './pgliteDialect.js';
+import { type PgliteDatabase, PgliteQuerier } from './pgliteQuerier.js';
+/**
+ * The driver's own options, minus the `dataDir` this pool takes as its first argument.
+ *
+ * @remarks Imported rather than restated so extensions and the filesystem hooks keep their real types:
+ * `extensions: { vector }` from `@electric-sql/pglite-pgvector` is how a vector column becomes usable,
+ * mirroring `LocalSqlitePoolOptions.extensions` for `sqlite-vec`. Type-only, like the `pg` imports in
+ * `abstractPgQuerierPool.ts`, so nothing here reaches a runtime without the peer installed.
+ */
+export type PglitePoolOptions = Omit<PGliteOptions, 'dataDir'>;
+/**
+ * Pool for PGlite, Postgres compiled to WASM and run in this process. No server, no container.
+ *
+ * PGlite is single connection, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.
+ * Where PGlite differs from the two SQLite-family pools there is that it does not refuse a second
+ * `BEGIN`: a querier that opens a transaction while another already has one silently joins it, and that
+ * one's `ROLLBACK` then discards both queriers' writes. Nothing reports it, so a unit of work that needs
+ * a transaction of its own needs its own pool, and therefore its own database.
+ *
+ * @remarks Transactions are plain `BEGIN`/`COMMIT` statements rather than `db.transaction()`, whose
+ * callback holds PGlite's transaction mutex and would block every other querier's reads until commit.
+ * The cost is that PGlite cannot see the transaction, so it flushes to the filesystem after each
+ * statement within one: pass `relaxedDurability: true` on a persistent `dataDir` to skip waiting on
+ * those flushes.
+ */
+export declare class PgliteQuerierPool extends AbstractSharedHandleQuerierPool<PgliteDatabase, PgliteQuerier, PgliteDialect> {
+    readonly dataDir: string;
+    readonly opts?: PglitePoolOptions | undefined;
+    constructor(dataDir?: string, opts?: PglitePoolOptions | undefined, extra?: ExtraOptions);
+    protected openDb(): Promise<PgliteDatabase>;
+    protected buildQuerier(db: PgliteDatabase): PgliteQuerier;
+}

package/dist/pglite/pgliteQuerierPool.js

@@ -0,0 +1,36 @@
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
+import { PgliteDialect } from './pgliteDialect.js';
+import { PgliteQuerier } from './pgliteQuerier.js';
+/**
+ * Pool for PGlite, Postgres compiled to WASM and run in this process. No server, no container.
+ *
+ * PGlite is single connection, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.
+ * Where PGlite differs from the two SQLite-family pools there is that it does not refuse a second
+ * `BEGIN`: a querier that opens a transaction while another already has one silently joins it, and that
+ * one's `ROLLBACK` then discards both queriers' writes. Nothing reports it, so a unit of work that needs
+ * a transaction of its own needs its own pool, and therefore its own database.
+ *
+ * @remarks Transactions are plain `BEGIN`/`COMMIT` statements rather than `db.transaction()`, whose
+ * callback holds PGlite's transaction mutex and would block every other querier's reads until commit.
+ * The cost is that PGlite cannot see the transaction, so it flushes to the filesystem after each
+ * statement within one: pass `relaxedDurability: true` on a persistent `dataDir` to skip waiting on
+ * those flushes.
+ */
+export class PgliteQuerierPool extends AbstractSharedHandleQuerierPool {
+    dataDir;
+    opts;
+    constructor(dataDir = 'memory://', opts, extra) {
+        super(new PgliteDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        this.dataDir = dataDir;
+        this.opts = opts;
+    }
+    async openDb() {
+        const { PGlite } = await import('@electric-sql/pglite');
+        // The declared return type is what checks {@link PgliteDatabase} against the real driver, so no
+        // cast is needed here or anywhere below it.
+        return PGlite.create(this.dataDir, this.opts);
+    }
+    buildQuerier(db) {
+        return new PgliteQuerier(db, this.dialect, this.extra);
+    }
+}

package/dist/querier/abstractSharedHandleQuerierPool.d.ts

@@ -0,0 +1,42 @@
+import type { AbstractSqlDialect } from '../dialect/index.js';
+import type { SqlQuerier } from '../type/index.js';
+import { AbstractSqlQuerierPool } from './abstractSqlQuerierPool.js';
+/**
+ * Base pool for an engine that gives one connection per database and keeps it open for the pool's
+ * lifetime: every local SQLite driver, the embedded Turso engine, and PGlite.
+ *
+ * The handle is shared, but each acquisition gets its own querier, so transaction state stays per unit
+ * of work. That state is not *isolated*, which is the one way these differ from a real pool: there is a
+ * single connection under every querier, so two of them cannot hold independent transactions, and a
+ * unit of work that needs one needs its own pool and therefore its own database.
+ *
+ * What a second `BEGIN` then does is the engine's, not this class's: SQLite and the embedded Turso
+ * engine both refuse it ("cannot start a transaction within a transaction"), while PGlite accepts it
+ * into the transaction already open - see {@link PgliteQuerierPool}, which is why that one is worth
+ * saying out loud.
+ *
+ * Subclasses supply only how to open the handle and how to wrap it, the way {@link AbstractPgQuerierPool}
+ * takes `buildQuerier` alone. The lazy open and the close were written out once per pool before, along
+ * with three partial copies of the paragraph above.
+ *
+ * @remarks Deliberately not re-exported from `querier/index.ts`, which the root entry point re-exports:
+ * only the three driver entries need this, and each imports it by path, as `postgres/abstractPgQuerier.ts`
+ * is imported.
+ */
+export declare abstract class AbstractSharedHandleQuerierPool<DB extends {
+    close(): unknown;
+}, Q extends SqlQuerier, D extends AbstractSqlDialect> extends AbstractSqlQuerierPool<Q, D> {
+    /**
+     * The open, not the handle: `db ??= await openDb()` reads before the await and assigns after, so
+     * callers arriving while the first open is in flight each start one of their own. The extra handles
+     * are then unreachable and never closed, and on an in-memory database they are separate databases,
+     * so a querier built on one writes where nothing else will ever read.
+     */
+    private opening?;
+    /** Opens the one connection. Called on the first acquisition, and again after an {@link end}. */
+    protected abstract openDb(): Promise<DB>;
+    /** Wraps the shared handle in a querier: the only thing that varies between these pools. */
+    protected abstract buildQuerier(db: DB): Q;
+    getQuerier(): Promise<Q>;
+    end(): Promise<void>;
+}

package/dist/querier/abstractSharedHandleQuerierPool.js

@@ -0,0 +1,48 @@
+import { AbstractSqlQuerierPool } from './abstractSqlQuerierPool.js';
+/**
+ * Base pool for an engine that gives one connection per database and keeps it open for the pool's
+ * lifetime: every local SQLite driver, the embedded Turso engine, and PGlite.
+ *
+ * The handle is shared, but each acquisition gets its own querier, so transaction state stays per unit
+ * of work. That state is not *isolated*, which is the one way these differ from a real pool: there is a
+ * single connection under every querier, so two of them cannot hold independent transactions, and a
+ * unit of work that needs one needs its own pool and therefore its own database.
+ *
+ * What a second `BEGIN` then does is the engine's, not this class's: SQLite and the embedded Turso
+ * engine both refuse it ("cannot start a transaction within a transaction"), while PGlite accepts it
+ * into the transaction already open - see {@link PgliteQuerierPool}, which is why that one is worth
+ * saying out loud.
+ *
+ * Subclasses supply only how to open the handle and how to wrap it, the way {@link AbstractPgQuerierPool}
+ * takes `buildQuerier` alone. The lazy open and the close were written out once per pool before, along
+ * with three partial copies of the paragraph above.
+ *
+ * @remarks Deliberately not re-exported from `querier/index.ts`, which the root entry point re-exports:
+ * only the three driver entries need this, and each imports it by path, as `postgres/abstractPgQuerier.ts`
+ * is imported.
+ */
+export class AbstractSharedHandleQuerierPool extends AbstractSqlQuerierPool {
+    /**
+     * The open, not the handle: `db ??= await openDb()` reads before the await and assigns after, so
+     * callers arriving while the first open is in flight each start one of their own. The extra handles
+     * are then unreachable and never closed, and on an in-memory database they are separate databases,
+     * so a querier built on one writes where nothing else will ever read.
+     */
+    opening;
+    async getQuerier() {
+        // Cleared on failure, so a driver that could not start once is retried rather than refused forever.
+        this.opening ??= this.openDb().catch((err) => {
+            this.opening = undefined;
+            throw err;
+        });
+        return this.buildQuerier(await this.opening);
+    }
+    async end() {
+        const opening = this.opening;
+        this.opening = undefined;
+        // An open still in flight is awaited rather than abandoned: closing is what releases its file or port.
+        // One that failed leaves nothing to close, and `getQuerier` already reported it to its own caller.
+        const db = await opening?.catch(() => undefined);
+        await db?.close();
+    }
+}

package/dist/sqlite/localSqliteQuerierPool.d.ts

@@ -1,4 +1,4 @@
-import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import type { ExtraOptions } from '../type/index.js';
 import { SqliteDialect } from './sqliteDialect.js';
 import { type SqliteDatabase, SqliteQuerier } from './sqliteQuerier.js';
@@ -12,20 +12,17 @@ export type LocalSqlitePoolOptions = {
     extensions?: readonly string[];
 };
 /**
- * Pool for a SQLite database opened in this process, whichever driver provides it.
+ * Pool for a SQLite database opened in this process, whichever driver provides it. SQLite gives one
+ * connection per file, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.
  *
- * The handle is shared - SQLite gives one connection per file - but each acquisition gets its own
- * querier, so transaction state stays per unit of work. Subclasses supply only {@link createDb}: the
- * lifecycle, and loading the extensions on the way up, are the same for `better-sqlite3`, `bun:sqlite`
- * and `node:sqlite`, and were written out once per pool before.
+ * Subclasses supply only {@link createDb}: loading the extensions on the way up is the same for
+ * `better-sqlite3`, `bun:sqlite` and `node:sqlite`, and was written out once per pool before.
  */
-export declare abstract class AbstractLocalSqliteQuerierPool<O extends LocalSqlitePoolOptions> extends AbstractSqlQuerierPool<SqliteQuerier, SqliteDialect> {
+export declare abstract class AbstractLocalSqliteQuerierPool<O extends LocalSqlitePoolOptions> extends AbstractSharedHandleQuerierPool<SqliteDatabase, SqliteQuerier, SqliteDialect> {
     readonly opts?: O | undefined;
-    private db?;
     constructor(opts?: O | undefined, extra?: ExtraOptions);
     /** Opens the driver's database. Extensions are loaded by the caller, not here. */
     protected abstract createDb(): Promise<SqliteDatabase>;
-    getQuerier(): Promise<SqliteQuerier>;
-    private openDb;
-    end(): Promise<void>;
+    protected openDb(): Promise<SqliteDatabase>;
+    protected buildQuerier(db: SqliteDatabase): SqliteQuerier;
 }

package/dist/sqlite/localSqliteQuerierPool.js

@@ -1,25 +1,19 @@
-import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { SqliteDialect } from './sqliteDialect.js';
 import { SqliteQuerier } from './sqliteQuerier.js';
 /**
- * Pool for a SQLite database opened in this process, whichever driver provides it.
+ * Pool for a SQLite database opened in this process, whichever driver provides it. SQLite gives one
+ * connection per file, so the shared-handle lifecycle is {@link AbstractSharedHandleQuerierPool}'s.
  *
- * The handle is shared - SQLite gives one connection per file - but each acquisition gets its own
- * querier, so transaction state stays per unit of work. Subclasses supply only {@link createDb}: the
- * lifecycle, and loading the extensions on the way up, are the same for `better-sqlite3`, `bun:sqlite`
- * and `node:sqlite`, and were written out once per pool before.
+ * Subclasses supply only {@link createDb}: loading the extensions on the way up is the same for
+ * `better-sqlite3`, `bun:sqlite` and `node:sqlite`, and was written out once per pool before.
  */
-export class AbstractLocalSqliteQuerierPool extends AbstractSqlQuerierPool {
+export class AbstractLocalSqliteQuerierPool extends AbstractSharedHandleQuerierPool {
     opts;
-    db;
     constructor(opts, extra) {
         super(new SqliteDialect({ namingStrategy: extra?.namingStrategy }), extra);
         this.opts = opts;
     }
-    async getQuerier() {
-        this.db ??= await this.openDb();
-        return new SqliteQuerier(this.db, this.dialect, this.extra);
-    }
     async openDb() {
         const db = await this.createDb();
         for (const extension of this.opts?.extensions ?? []) {
@@ -27,8 +21,7 @@ export class AbstractLocalSqliteQuerierPool extends AbstractSqlQuerierPool {
         }
         return db;
     }
-    async end() {
-        await this.db?.close();
-        this.db = undefined;
+    buildQuerier(db) {
+        return new SqliteQuerier(db, this.dialect, this.extra);
     }
 }

package/dist/turso/tursoLocalQuerierPool.d.ts

@@ -1,7 +1,7 @@
-import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import type { ExtraOptions } from '../type/index.js';
 import { TursoDialect } from './tursoDialect.js';
-import { TursoLocalQuerier } from './tursoLocalQuerier.js';
+import { type TursoDatabase, TursoLocalQuerier } from './tursoLocalQuerier.js';
 /** Subset of `DatabaseOpts` from `@tursodatabase/database`, declared locally to avoid the coupling. */
 export type TursoLocalOptions = {
     readonly?: boolean;
@@ -17,16 +17,10 @@ export type TursoLocalOptions = {
  * package ships native binaries that do not resolve on edge runtimes. Separating them guarantees a
  * bundle targeting Workers never reaches the native import.
  */
-export declare class TursoLocalQuerierPool extends AbstractSqlQuerierPool<TursoLocalQuerier, TursoDialect> {
+export declare class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool<TursoDatabase, TursoLocalQuerier, TursoDialect> {
     readonly filename: string;
     readonly opts?: TursoLocalOptions | undefined;
-    private db?;
     constructor(filename?: string, opts?: TursoLocalOptions | undefined, extra?: ExtraOptions);
-    /**
-     * The database handle is shared (single connection), but each acquisition gets its own querier
-     * so transaction state stays per unit of work.
-     */
-    getQuerier(): Promise<TursoLocalQuerier>;
-    private openDb;
-    end(): Promise<void>;
+    protected openDb(): Promise<TursoDatabase>;
+    protected buildQuerier(db: TursoDatabase): TursoLocalQuerier;
 }

package/dist/turso/tursoLocalQuerierPool.js

@@ -1,4 +1,4 @@
-import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
 import { TursoDialect } from './tursoDialect.js';
 import { TursoLocalQuerier } from './tursoLocalQuerier.js';
 /**
@@ -8,23 +8,14 @@ import { TursoLocalQuerier } from './tursoLocalQuerier.js';
  * package ships native binaries that do not resolve on edge runtimes. Separating them guarantees a
  * bundle targeting Workers never reaches the native import.
  */
-export class TursoLocalQuerierPool extends AbstractSqlQuerierPool {
+export class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool {
     filename;
     opts;
-    db;
     constructor(filename = ':memory:', opts, extra) {
         super(new TursoDialect({ namingStrategy: extra?.namingStrategy }), extra);
         this.filename = filename;
         this.opts = opts;
     }
-    /**
-     * The database handle is shared (single connection), but each acquisition gets its own querier
-     * so transaction state stays per unit of work.
-     */
-    async getQuerier() {
-        this.db ??= await this.openDb();
-        return new TursoLocalQuerier(this.db, this.dialect, this.extra);
-    }
     async openDb() {
         const { connect } = await import('@tursodatabase/database');
         // Annotated rather than cast, so the structural contract is checked against the real driver.
@@ -33,8 +24,7 @@ export class TursoLocalQuerierPool extends AbstractSqlQuerierPool {
         await db.pragma('foreign_keys = ON');
         return db;
     }
-    async end() {
-        await this.db?.close();
-        this.db = undefined;
+    buildQuerier(db) {
+        return new TursoLocalQuerier(db, this.dialect, this.extra);
     }
 }

package/dist/type/entity.d.ts

@@ -1,7 +1,7 @@
 import type { ForeignKeyAction, IndexType } from '../schema/types.js';
 import type { FilterOptions } from './query.js';
 import type { QueryRaw } from './queryRaw.js';
-import type { Except, Json, Scalar, Type, Unpacked } from './utility.js';
+import type { Except, IsMany, Json, Scalar, Type, Unpacked } from './utility.js';
 import type { VectorDistance, VectorIndexOptions, VectorIndexType } from './vector.js';
 /**
  * Allow to customize the name of the property that identifies an entity
@@ -18,10 +18,12 @@ export type Key<E> = keyof E & string;
  * (without it, optional properties leak `undefined` into the union).
  *
  * The check is bracketed so `any` resolves once rather than matching both this and
- * {@link RelationKey}: an unbracketed `any extends X` satisfies either branch.
+ * {@link RelationKey}: an unbracketed `any extends X` satisfies either branch. It reads
+ * `readonly Scalar[]`, which every mutable one satisfies too, so declaring a vector or a scalar
+ * array `readonly` does not push the field over into {@link RelationKey}.
  */
 export type FieldKey<E> = {
-    readonly [K in keyof E]-?: [NonNullable<E[K]>] extends [Scalar | Scalar[] | Json] ? K : never;
+    readonly [K in keyof E]-?: [NonNullable<E[K]>] extends [Scalar | readonly Scalar[] | Json] ? K : never;
 }[Key<E>];
 /**
  * Infers the relation names of an entity: whatever is left once its fields and its methods are
@@ -79,7 +81,7 @@ export type JsonFieldPathValue<E, P extends string> = P extends `${infer F}.${in
  * Used by `$push` and `$pull` to provide type-safe element targets.
  */
 export type JsonArrayFields<T> = {
-    [K in keyof T as NonNullable<T[K]> extends readonly unknown[] ? K & string : never]?: Unpacked<NonNullable<T[K]>>;
+    [K in keyof T as IsMany<T[K]> extends true ? K & string : never]?: Unpacked<NonNullable<T[K]>>;
 };
 /**
  * Operator shape accepted by JSON/JSONB fields in update payloads: `$set`/`$unset` target object
@@ -119,7 +121,7 @@ export type JsonUpdateOp<T = unknown> = {
  *   `JSON_SET(arr, '$.k', v)` is a no-op on MySQL and SQLite. Replace the whole value instead.
  *   `Json<unknown>` stays permissive, since `unknown` is not an array.
  */
-type JsonUpdateOpFor<V, T = UnwrapJson<NonNullable<V>>> = [T] extends [never] ? never : T extends readonly unknown[] ? never : JsonUpdateOp<T>;
+type JsonUpdateOpFor<V, T = UnwrapJson<NonNullable<V>>> = [T] extends [never] ? never : IsMany<T> extends true ? never : JsonUpdateOp<T>;
 /**
  * Accepted value for a single field in an update payload: the value itself, `null` where the column
  * is nullable, `QueryRaw` for a raw SQL expression (e.g. `raw('NOW()')`), and - for JSON object
@@ -369,8 +371,8 @@ export type RelationTarget<V> = NonNullable<Unpacked<NonNullable<V>>>;
  */
 export type RelationOptionsFor<V> = Omit<RelationOptions<RelationTarget<V>>, 'entity' | 'cardinality'> & {
     readonly entity: EntityGetter<RelationTarget<V>>;
-    readonly cardinality: NonNullable<V> extends readonly unknown[] ? '1m' | 'mm' : '11' | 'm1';
-} & (NonNullable<V> extends readonly unknown[] ? RelationJoin<RelationTarget<V>> : unknown);
+    readonly cardinality: IsMany<V> extends true ? '1m' | 'mm' : '11' | 'm1';
+} & (IsMany<V> extends true ? RelationJoin<RelationTarget<V>> : unknown);
 /**
  * The method names of an entity, so hook registrations name a method that exists.
  */

package/dist/type/query.d.ts

@@ -1,8 +1,8 @@
-import type { FieldKey, JsonFieldPaths, RelationKey } from './entity.js';
+import type { FieldKey, JsonFieldPaths, RelationKey, RelationTarget } from './entity.js';
 import type { QueryLock } from './queryLock.js';
 import type { QueryRaw } from './queryRaw.js';
 import type { QueryWhere } from './queryWhere.js';
-import type { BooleanLike, Except, PrimaryKey, Unpacked } from './utility.js';
+import type { BooleanLike, Except, IsMany, PrimaryKey } from './utility.js';
 import type { QueryVectorSearch } from './vector.js';
 export type QueryOptions = {
     /**
@@ -64,9 +64,9 @@ export type QueryConflictPaths<E> = {
     [K in FieldKey<E>]?: true;
 };
 /**
- * options to populate a relation.
+ * Options to populate a relation declared as `V`, by its cardinality.
  */
-export type QueryPopulateRelationOptions<E> = (E extends unknown[] ? Except<Query<Unpacked<E>>, '$lock'> : QueryUnique<Unpacked<E>>) & {
+export type QueryPopulateRelationOptions<V> = (IsMany<V> extends true ? Except<Query<RelationTarget<V>>, '$lock'> : QueryUnique<RelationTarget<V>>) & {
     $required?: boolean;
 };
 /**
@@ -126,7 +126,7 @@ export type QuerySortMap<E, Vector extends boolean = true> = {
 } & {
     [P in JsonFieldPaths<E>]?: QuerySortDirection;
 } & {
-    [K in RelationKey<E> as NonNullable<E[K]> extends readonly unknown[] ? never : K]?: QuerySortMap<NonNullable<E[K]>, false>;
+    [K in RelationKey<E> as IsMany<E[K]> extends true ? never : K]?: QuerySortMap<RelationTarget<E[K]>, false>;
 };
 /**
  * pager options.

package/dist/type/queryWhere.d.ts

@@ -1,6 +1,6 @@
-import type { FieldKey, IdValue, JsonFieldPaths, JsonFieldPathValue, RelationKey } from './entity.js';
+import type { FieldKey, IdValue, JsonFieldPaths, JsonFieldPathValue, RelationKey, RelationTarget } from './entity.js';
 import type { QueryRaw } from './queryRaw.js';
-import type { ExpandScalar, QueryComparableScalar, Scalar, Unpacked } from './utility.js';
+import type { ExpandScalar, IsMany, QueryComparableScalar, Scalar } from './utility.js';
 /**
  * options for full-text-search operator.
  */
@@ -35,7 +35,7 @@ export type QueryWhereFieldMap<E> = {
 export type QueryWhereMap<E> = QueryWhereFieldMap<E> & QueryWhereRootOperator<E> & {
     [P in JsonFieldPaths<E>]?: QueryWhereFieldValue<JsonFieldPathValue<E, P>>;
 } & {
-    [K in RelationKey<E>]?: QueryWhereMap<Unpacked<NonNullable<E[K]>>> | QueryRelationSizeFilter;
+    [K in RelationKey<E>]?: QueryWhereMap<RelationTarget<E[K]>> | QueryRelationSizeFilter;
 };
 /**
  * Filter a to-many relation by its row count.
@@ -246,7 +246,7 @@ type QueryCommonOp = Exclude<keyof QueryWhereFieldOperatorMap<unknown>, QueryStr
  * Operator keys applicable to a field of type `T`. Brackets prevent union distribution so an
  * optional field (`string | undefined`) or a literal union (`'a' | 'b'`) gates as one type.
  */
-type QueryAllowedOp<T> = QueryCommonOp | ([NonNullable<T>] extends [QueryComparableScalar] ? QueryOrderedOp : never) | ([NonNullable<T>] extends [string] ? QueryStringOp : never) | ([NonNullable<T>] extends [readonly unknown[]] ? QueryArrayOp : never);
+type QueryAllowedOp<T> = QueryCommonOp | ([NonNullable<T>] extends [QueryComparableScalar] ? QueryOrderedOp : never) | ([NonNullable<T>] extends [string] ? QueryStringOp : never) | (IsMany<T> extends true ? QueryArrayOp : never);
 /**
  * Operators applicable to a field of type `T`: string operators require string fields, ordering
  * operators comparable fields, array operators array fields. `unknown` stays fully permissive
@@ -261,7 +261,7 @@ export type QueryWhereFieldOperators<T> = unknown extends T ? QueryWhereFieldOpe
  * `null` is accepted on a nullable field (an optional property is a nullable column), matching what
  * `$eq: null` already took.
  */
-export type QueryWhereFieldValue<T> = T | (undefined extends T ? null : never) | ([NonNullable<T>] extends [readonly unknown[]] ? never : T[]) | QueryWhereFieldOperators<T> | QueryRaw;
+export type QueryWhereFieldValue<T> = T | (undefined extends T ? null : never) | (IsMany<T> extends true ? never : T[]) | QueryWhereFieldOperators<T> | QueryRaw;
 /**
  * query filter array - used for `$and`, `$or`, `$not`, `$nor` operators.
  */

package/dist/type/universalQuerier.d.ts

@@ -55,8 +55,10 @@ export interface UniversalQuerier {
     /**
      * Insert a single record and return its ID (provided, `onInsert`-generated, or
      * database-generated - see {@link UniversalQuerier.insertMany} for the exact semantics).
-     * Returns `undefined` when the ID cannot be determined (e.g. MySQL/SQLite non-auto-increment
-     * keys in batches without explicit IDs).
+     * Returns `undefined` only where the database cannot report one: MySQL, whose `LAST_INSERT_ID()`
+     * speaks for `AUTO_INCREMENT` columns alone and is left *stale* rather than cleared otherwise, so
+     * a non-auto-increment key the caller did not supply has no id to give and a header read would
+     * hand back an earlier row's. Every other backend uses `RETURNING` and is exact, SQLite included.
      * @param entity the entity to persist on
      * @param payload the data to be persisted
      * @return the ID

package/dist/type/utility.d.ts

@@ -58,3 +58,10 @@ export type Except<T, K extends keyof T> = {
     [P in keyof T as P extends K ? never : P]: T[P];
 };
 export type Unpacked<T> = T extends readonly (infer U)[] ? U : T extends (...args: unknown[]) => infer U ? U : T extends Promise<infer U> ? U : T;
+/**
+ * Whether the value a property holds is many rather than one: a to-many relation, a scalar array, a
+ * vector. Every array test in the type layer goes through this, because writing one by hand gets some
+ * part of it wrong in ways nothing reports. `isMany.test-d.ts` has one case per part, and says what
+ * each is load-bearing for.
+ */
+export type IsMany<V> = [NonNullable<V>] extends [readonly unknown[]] ? true : false;

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "uql-orm",
   "homepage": "https://uql-orm.dev",
-  "description": "JSON-native TypeScript ORM for Node.js, Bun and Deno. Supports PostgreSQL, MySQL, MariaDB, SQLite, CockroachDB, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
+  "description": "JSON-native TypeScript ORM for Node.js, Bun and Deno. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -47,6 +47,7 @@
     "./turso": "./dist/turso/index.js",
     "./turso/local": "./dist/turso/local.js",
     "./neon": "./dist/neon/index.js",
+    "./pglite": "./dist/pglite/index.js",
     "./d1": "./dist/d1/index.js",
     "./bunSql": "./dist/bunSql/index.js",
     "./package.json": "./package.json"
@@ -64,6 +65,7 @@
     "clean": "rimraf dist .tsconfig.tsbuildinfo"
   },
   "peerDependencies": {
+    "@electric-sql/pglite": ">=0.5.0",
     "@libsql/client": ">=0.6.0",
     "@neondatabase/serverless": ">=0.9.0",
     "@nestjs/common": ">=10.0.0",
@@ -80,6 +82,9 @@
     "rxjs": ">=7.0.0"
   },
   "peerDependenciesMeta": {
+    "@electric-sql/pglite": {
+      "optional": true
+    },
     "@libsql/client": {
       "optional": true
     },
@@ -124,6 +129,8 @@
     }
   },
   "devDependencies": {
+    "@electric-sql/pglite": "0.5.7",
+    "@electric-sql/pglite-pgvector": "0.0.8",
     "@libsql/client": "^0.17.4",
     "@neondatabase/serverless": "^1.1.0",
     "@nestjs/common": "^11.2.1",
@@ -172,6 +179,8 @@
     "postgres",
     "postgresql",
     "pg",
+    "pglite",
+    "wasm",
     "mysql",
     "mariadb",
     "sqlite",