@centia-io/sdk 0.0.42 → 0.0.43

package/dist/centia-io-sdk.umd.js

@@ -5,1068 +5,1007 @@
 })(this, function(exports) {
 
 //#region src/util/jwt-decode.ts
-	var InvalidTokenError = class extends Error {};
-	InvalidTokenError.prototype.name = "InvalidTokenError";
-	function b64DecodeUnicode(str) {
-		return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
-			let code = p.charCodeAt(0).toString(16).toUpperCase();
-			if (code.length < 2) code = "0" + code;
-			return "%" + code;
-		}));
-	}
-	function base64UrlDecode(str) {
-		let output = str.replace(/-/g, "+").replace(/_/g, "/");
-		switch (output.length % 4) {
-			case 0: break;
-			case 2:
-				output += "==";
-				break;
-			case 3:
-				output += "=";
-				break;
-			default: throw new Error("base64 string is not of the correct length");
-		}
-		try {
-			return b64DecodeUnicode(output);
-		} catch (err) {
-			return atob(output);
-		}
+var InvalidTokenError = class extends Error {};
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+	return decodeURIComponent(atob(str).replace(/(.)/g, (m, p) => {
+		let code = p.charCodeAt(0).toString(16).toUpperCase();
+		if (code.length < 2) code = "0" + code;
+		return "%" + code;
+	}));
+}
+function base64UrlDecode(str) {
+	let output = str.replace(/-/g, "+").replace(/_/g, "/");
+	switch (output.length % 4) {
+		case 0: break;
+		case 2:
+			output += "==";
+			break;
+		case 3:
+			output += "=";
+			break;
+		default: throw new Error("base64 string is not of the correct length");
 	}
-	function jwtDecode(token, options) {
-		if (typeof token !== "string") throw new InvalidTokenError("Invalid token specified: must be a string");
-		options ||= {};
-		const pos = options.header === true ? 0 : 1;
-		const part = token.split(".")[pos];
-		if (typeof part !== "string") throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
-		let decoded;
-		try {
-			decoded = base64UrlDecode(part);
-		} catch (e) {
-			throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
-		}
-		try {
-			return JSON.parse(decoded);
-		} catch (e) {
-			throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
-		}
+	try {
+		return b64DecodeUnicode(output);
+	} catch (err) {
+		return atob(output);
+	}
+}
+function jwtDecode(token, options) {
+	if (typeof token !== "string") throw new InvalidTokenError("Invalid token specified: must be a string");
+	options ||= {};
+	const pos = options.header === true ? 0 : 1;
+	const part = token.split(".")[pos];
+	if (typeof part !== "string") throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+	let decoded;
+	try {
+		decoded = base64UrlDecode(part);
+	} catch (e) {
+		throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
 	}
+	try {
+		return JSON.parse(decoded);
+	} catch (e) {
+		throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+	}
+}
 
 //#endregion
 //#region src/util/storage.ts
-	var MemoryStorage = class {
-		constructor() {
-			this.store = /* @__PURE__ */ new Map();
-		}
-		getItem(key) {
-			return this.store.has(key) ? this.store.get(key) : null;
-		}
-		setItem(key, value) {
-			this.store.set(key, String(value));
-		}
-		removeItem(key) {
-			this.store.delete(key);
-		}
-	};
-	let cached = null;
-	function getStorage() {
-		if (cached) return cached;
-		try {
-			const g$1 = typeof globalThis !== "undefined" ? globalThis : window;
-			if (g$1 && g$1.localStorage && typeof g$1.localStorage.getItem === "function") {
-				cached = g$1.localStorage;
-				return cached;
-			}
-		} catch (e) {}
-		const g = typeof globalThis !== "undefined" ? globalThis : {};
-		if (!g.__gc2_memory_storage) g.__gc2_memory_storage = new MemoryStorage();
-		cached = g.__gc2_memory_storage;
-		return cached;
+var MemoryStorage = class {
+	constructor() {
+		this.store = /* @__PURE__ */ new Map();
+	}
+	getItem(key) {
+		return this.store.has(key) ? this.store.get(key) : null;
+	}
+	setItem(key, value) {
+		this.store.set(key, String(value));
 	}
+	removeItem(key) {
+		this.store.delete(key);
+	}
+};
+let cached = null;
+function getStorage() {
+	if (cached) return cached;
+	try {
+		const g$1 = typeof globalThis !== "undefined" ? globalThis : window;
+		if (g$1 && g$1.localStorage && typeof g$1.localStorage.getItem === "function") {
+			cached = g$1.localStorage;
+			return cached;
+		}
+	} catch (e) {}
+	const g = typeof globalThis !== "undefined" ? globalThis : {};
+	if (!g.__gc2_memory_storage) g.__gc2_memory_storage = new MemoryStorage();
+	cached = g.__gc2_memory_storage;
+	return cached;
+}
 
 //#endregion
 //#region src/util/utils.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	const generatePkceChallenge = async () => {
-		const generateRandomString = () => {
-			const array = new Uint32Array(28);
-			crypto.getRandomValues(array);
-			return Array.from(array, (dec) => ("0" + dec.toString(16)).substr(-2)).join("");
-		};
-		const sha256 = (plain) => {
-			const data = new TextEncoder().encode(plain);
-			return crypto.subtle.digest("SHA-256", data);
-		};
-		const base64urlEncode = (str) => {
-			return btoa(String.fromCharCode.apply(null, [...new Uint8Array(str)])).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-		};
-		async function pkceChallengeFromVerifier(v) {
-			return base64urlEncode(await sha256(v));
-		}
-		const { state, codeVerifier } = {
-			state: generateRandomString(),
-			codeVerifier: generateRandomString()
-		};
-		return {
-			state,
-			codeVerifier,
-			codeChallenge: await pkceChallengeFromVerifier(codeVerifier)
-		};
-	};
-	const isTokenExpired = (token) => {
-		let isJwtExpired = false;
-		const { exp } = jwtDecode(token);
-		const currentTime = (/* @__PURE__ */ new Date()).getTime() / 1e3;
-		if (exp) {
-			if (currentTime > exp) isJwtExpired = true;
-		}
-		return isJwtExpired;
+const generatePkceChallenge = async () => {
+	const generateRandomString = () => {
+		const array = new Uint32Array(28);
+		crypto.getRandomValues(array);
+		return Array.from(array, (dec) => ("0" + dec.toString(16)).substr(-2)).join("");
 	};
-	const claims = (token) => {
-		return jwtDecode(token);
+	const sha256 = (plain) => {
+		const data = new TextEncoder().encode(plain);
+		return crypto.subtle.digest("SHA-256", data);
 	};
-	const isLogin = async (gc2) => {
-		const { accessToken, refreshToken } = getTokens();
-		if (!accessToken && !refreshToken) return false;
-		if (!accessToken || accessToken && isTokenExpired(accessToken)) {
-			if (refreshToken && isTokenExpired(refreshToken)) {
-				clearTokens();
-				clearOptions();
-				throw new Error("Refresh token has expired. Please login again.");
-			}
-			if (refreshToken) try {
-				const data = await gc2.getRefreshToken(refreshToken);
-				setTokens({
-					accessToken: data.access_token,
-					refreshToken,
-					idToken: data?.id_token
-				});
-				console.log("Access token refreshed");
-			} catch (e) {
-				throw new Error("Could not get refresh token.");
-			}
-		}
-		return true;
-	};
-	const setTokens = (tokens) => {
-		getStorage().setItem("gc2_tokens", JSON.stringify({
-			"accessToken": tokens.accessToken,
-			"refreshToken": tokens.refreshToken,
-			"idToken": tokens?.idToken || ""
-		}));
+	const base64urlEncode = (str) => {
+		return btoa(String.fromCharCode.apply(null, [...new Uint8Array(str)])).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 	};
-	const getTokens = () => {
-		const str = getStorage().getItem("gc2_tokens");
-		const tokens = str ? JSON.parse(str) : {};
-		return {
-			accessToken: tokens?.accessToken || "",
-			refreshToken: tokens?.refreshToken || "",
-			idToken: tokens?.idToken || ""
-		};
-	};
-	const setOptions = (options) => {
-		getStorage().setItem("gc2_options", JSON.stringify({
-			"clientId": options.clientId,
-			"host": options.host,
-			"redirectUri": options.redirectUri,
-			"clientSecret": options.clientSecret || null
-		}));
-	};
-	const getOptions = () => {
-		const str = getStorage().getItem("gc2_options");
-		const options = str ? JSON.parse(str) : {};
-		return {
-			clientId: options?.clientId || "",
-			host: options?.host || "",
-			redirectUri: options?.redirectUri || ""
-		};
-	};
-	const clearTokens = () => {
-		getStorage().removeItem("gc2_tokens");
+	async function pkceChallengeFromVerifier(v) {
+		return base64urlEncode(await sha256(v));
+	}
+	const { state, codeVerifier } = {
+		state: generateRandomString(),
+		codeVerifier: generateRandomString()
 	};
-	const clearOptions = () => {
-		getStorage().removeItem("gc2_options");
+	return {
+		state,
+		codeVerifier,
+		codeChallenge: await pkceChallengeFromVerifier(codeVerifier)
 	};
-	const getNonce = () => {
-		return getStorage().getItem("gc2_nonce");
+};
+const isTokenExpired = (token) => {
+	let isJwtExpired = false;
+	const { exp } = jwtDecode(token);
+	const currentTime = (/* @__PURE__ */ new Date()).getTime() / 1e3;
+	if (exp) {
+		if (currentTime > exp) isJwtExpired = true;
+	}
+	return isJwtExpired;
+};
+const claims = (token) => {
+	return jwtDecode(token);
+};
+const isLogin = async (gc2) => {
+	const { accessToken, refreshToken } = getTokens();
+	if (!accessToken && !refreshToken) return false;
+	if (!accessToken || accessToken && isTokenExpired(accessToken)) {
+		if (refreshToken && isTokenExpired(refreshToken)) {
+			clearTokens();
+			clearOptions();
+			throw new Error("Refresh token has expired. Please login again.");
+		}
+		if (refreshToken) try {
+			const data = await gc2.getRefreshToken(refreshToken);
+			setTokens({
+				accessToken: data.access_token,
+				refreshToken,
+				idToken: data?.id_token
+			});
+			console.log("Access token refreshed");
+		} catch (e) {
+			throw new Error("Could not get refresh token.");
+		}
+	}
+	return true;
+};
+const setTokens = (tokens) => {
+	getStorage().setItem("gc2_tokens", JSON.stringify({
+		"accessToken": tokens.accessToken,
+		"refreshToken": tokens.refreshToken,
+		"idToken": tokens?.idToken || ""
+	}));
+};
+const getTokens = () => {
+	const str = getStorage().getItem("gc2_tokens");
+	const tokens = str ? JSON.parse(str) : {};
+	return {
+		accessToken: tokens?.accessToken || "",
+		refreshToken: tokens?.refreshToken || "",
+		idToken: tokens?.idToken || ""
 	};
-	const clearNonce = () => {
-		getStorage().removeItem("gc2_nonce");
+};
+const setOptions = (options) => {
+	getStorage().setItem("gc2_options", JSON.stringify({
+		"clientId": options.clientId,
+		"host": options.host,
+		"redirectUri": options.redirectUri
+	}));
+};
+const getOptions = () => {
+	const str = getStorage().getItem("gc2_options");
+	const options = str ? JSON.parse(str) : {};
+	return {
+		clientId: options?.clientId || "",
+		host: options?.host || "",
+		redirectUri: options?.redirectUri || ""
 	};
+};
+const clearTokens = () => {
+	getStorage().removeItem("gc2_tokens");
+};
+const clearOptions = () => {
+	getStorage().removeItem("gc2_options");
+};
+const getNonce = () => {
+	return getStorage().getItem("gc2_nonce");
+};
+const clearNonce = () => {
+	getStorage().removeItem("gc2_nonce");
+};
 
 //#endregion
 //#region src/services/gc2.services.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Gc2Service = class {
-		constructor(options) {
-			this.options = options;
-			this.host = options.host;
-		}
-		isCodeFlowOptions(options) {
-			return "redirectUri" in options;
-		}
-		isPasswordFlowOptions(options) {
-			return "username" in options;
-		}
-		isSignUpOptions(options) {
-			return "parentDb" in options;
-		}
-		buildUrl(path) {
-			if (path.startsWith("http://") || path.startsWith("https://")) return path;
-			return `${this.host}${path}`;
-		}
-		async request(url, method, body, contentType = "application/json") {
-			const headers = { "Content-Type": contentType };
-			let payload;
-			if (contentType === "application/json") payload = JSON.stringify(body);
-			else payload = new URLSearchParams(body).toString();
-			const response = await fetch(url, {
-				method,
-				headers,
-				body: payload
-			});
-			if (!response.ok) {
-				const errText = await response.text();
-				throw new Error(`HTTP error ${response.status}: ${errText}`);
-			}
-			return response.json();
-		}
-		async getDeviceCode() {
-			const path = this.options.deviceUri ?? `${this.host}/api/v4/oauth/device`;
-			return this.request(this.buildUrl(path), "POST", { client_id: this.options.clientId });
-		}
-		async pollToken(deviceCode, interval) {
-			const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
-			const getToken = async () => {
-				try {
-					return await this.request(this.buildUrl(path), "POST", {
-						client_id: this.options.clientId,
-						device_code: deviceCode,
-						grant_type: "device_code"
-					});
-				} catch (e) {
-					const err = JSON.parse(e.message.split(": ")[1]);
-					if (err.error === "authorization_pending") return null;
-					return err.error_description;
-				}
-			};
-			let response = await getToken();
-			while (response === null) {
-				await new Promise((resolve) => setTimeout(resolve, interval * 1100));
-				response = await getToken();
+var Gc2Service = class {
+	constructor(options) {
+		this.options = options;
+		this.host = options.host;
+	}
+	isCodeFlowOptions(options) {
+		return "redirectUri" in options;
+	}
+	isPasswordFlowOptions(options) {
+		return "username" in options;
+	}
+	isSignUpOptions(options) {
+		return "parentDb" in options;
+	}
+	buildUrl(path) {
+		if (path.startsWith("http://") || path.startsWith("https://")) return path;
+		return `${this.host}${path}`;
+	}
+	async request(url, method, body, contentType = "application/json") {
+		const headers = { "Content-Type": contentType };
+		let payload;
+		if (contentType === "application/json") payload = JSON.stringify(body);
+		else payload = new URLSearchParams(body).toString();
+		const response = await fetch(url, {
+			method,
+			headers,
+			body: payload
+		});
+		if (!response.ok) {
+			const errText = await response.text();
+			throw new Error(`HTTP error ${response.status}: ${errText}`);
+		}
+		return response.json();
+	}
+	async getDeviceCode() {
+		const path = this.options.deviceUri ?? `${this.host}/api/v4/oauth/device`;
+		return this.request(this.buildUrl(path), "POST", { client_id: this.options.clientId });
+	}
+	async pollToken(deviceCode, interval) {
+		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+		const getToken = async () => {
+			try {
+				return await this.request(this.buildUrl(path), "POST", {
+					client_id: this.options.clientId,
+					device_code: deviceCode,
+					grant_type: "device_code"
+				});
+			} catch (e) {
+				const err = JSON.parse(e.message.split(": ")[1]);
+				if (err.error === "authorization_pending") return null;
+				return err.error_description;
 			}
-			if (typeof response === "string") throw new Error(response);
-			return response;
-		}
-		getAuthorizationCodeURL(codeChallenge, state) {
-			let redirectUri;
-			if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
-			else throw new Error("CodeFlow options required for this operation");
-			const base = this.options.authUri ?? `${this.host}/auth/`;
-			const params = new URLSearchParams();
-			const nonce = getNonce();
-			params.set("response_type", "code");
-			params.set("client_id", this.options.clientId);
-			params.set("redirect_uri", redirectUri);
-			params.set("state", state);
-			params.set("code_challenge", codeChallenge);
-			params.set("code_challenge_method", "S256");
-			if (nonce) params.set("nonce", nonce);
-			if (this.options.scope) params.set("scope", this.options.scope);
-			return `${base}?${params.toString()}`;
-		}
-		getSignUpURL() {
-			if (!this.isSignUpOptions(this.options)) throw new Error("CodeFlow options required for this operation");
-			const base = this.options.authUri ?? `${this.host}/signup/`;
-			const params = new URLSearchParams();
-			params.set("client_id", this.options.clientId);
-			params.set("parentdb", this.options.parentDb);
-			params.set("redirect_uri", this.options.redirectUri);
-			return `${base}?${params.toString()}`;
-		}
-		async getAuthorizationCodeToken(code, codeVerifier) {
-			let redirectUri;
-			if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
-			else throw new Error("CodeFlow options required for this operation");
-			const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
-			return this.request(this.buildUrl(path), "POST", {
-				client_id: this.options.clientId,
-				redirect_uri: redirectUri,
-				grant_type: "authorization_code",
-				code,
-				code_verifier: codeVerifier
-			}, "application/x-www-form-urlencoded");
-		}
-		async getPasswordToken() {
-			let username, password, database;
-			if (this.isPasswordFlowOptions(this.options)) {
-				username = this.options.username;
-				password = this.options.password;
-				database = this.options.database;
-			} else throw new Error("PasswordFlow options required for this operation");
-			const path = `${this.host}/api/v4/oauth`;
-			return this.request(this.buildUrl(path), "POST", {
-				client_id: this.options.clientId,
-				grant_type: "password",
-				username,
-				password,
-				database
-			});
-		}
-		async getRefreshToken(token) {
-			const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
-			return this.request(this.buildUrl(path), "POST", {
-				client_id: this.options.clientId,
-				grant_type: "refresh_token",
-				refresh_token: token
-			});
-		}
-		getSignOutURL() {
-			let redirectUri;
-			if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
-			else throw new Error("CodeFlow options required for this operation");
-			const params = new URLSearchParams({ redirect_uri: redirectUri });
-			return this.options.logoutUri ?? `${this.host}/signout?${params.toString()}`;
+		};
+		let response = await getToken();
+		while (response === null) {
+			await new Promise((resolve) => setTimeout(resolve, interval * 1100));
+			response = await getToken();
 		}
-	};
+		if (typeof response === "string") throw new Error(response);
+		return response;
+	}
+	getAuthorizationCodeURL(codeChallenge, state) {
+		let redirectUri;
+		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+		else throw new Error("CodeFlow options required for this operation");
+		const base = this.options.authUri ?? `${this.host}/auth/`;
+		const params = new URLSearchParams();
+		const nonce = getNonce();
+		params.set("response_type", "code");
+		params.set("client_id", this.options.clientId);
+		params.set("redirect_uri", redirectUri);
+		params.set("state", state);
+		params.set("code_challenge", codeChallenge);
+		params.set("code_challenge_method", "S256");
+		if (nonce) params.set("nonce", nonce);
+		if (this.options.scope) params.set("scope", this.options.scope);
+		return `${base}?${params.toString()}`;
+	}
+	getSignUpURL() {
+		if (!this.isSignUpOptions(this.options)) throw new Error("CodeFlow options required for this operation");
+		const base = this.options.authUri ?? `${this.host}/signup/`;
+		const params = new URLSearchParams();
+		params.set("client_id", this.options.clientId);
+		params.set("parentdb", this.options.parentDb);
+		params.set("redirect_uri", this.options.redirectUri);
+		return `${base}?${params.toString()}`;
+	}
+	async getAuthorizationCodeToken(code, codeVerifier) {
+		let redirectUri;
+		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+		else throw new Error("CodeFlow options required for this operation");
+		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+		return this.request(this.buildUrl(path), "POST", {
+			client_id: this.options.clientId,
+			redirect_uri: redirectUri,
+			grant_type: "authorization_code",
+			code,
+			code_verifier: codeVerifier
+		}, "application/x-www-form-urlencoded");
+	}
+	async getPasswordToken() {
+		let username, password, database;
+		if (this.isPasswordFlowOptions(this.options)) {
+			username = this.options.username;
+			password = this.options.password;
+			database = this.options.database;
+		} else throw new Error("PasswordFlow options required for this operation");
+		const path = `${this.host}/api/v4/oauth`;
+		return this.request(this.buildUrl(path), "POST", {
+			client_id: this.options.clientId,
+			grant_type: "password",
+			username,
+			password,
+			database
+		});
+	}
+	async getRefreshToken(token) {
+		const path = this.options.tokenUri ?? `${this.host}/api/v4/oauth`;
+		return this.request(this.buildUrl(path), "POST", {
+			client_id: this.options.clientId,
+			grant_type: "refresh_token",
+			refresh_token: token
+		});
+	}
+	getSignOutURL() {
+		let redirectUri;
+		if (this.isCodeFlowOptions(this.options)) redirectUri = this.options.redirectUri;
+		else throw new Error("CodeFlow options required for this operation");
+		const params = new URLSearchParams({ redirect_uri: redirectUri });
+		return this.options.logoutUri ?? `${this.host}/signout?${params.toString()}`;
+	}
+};
 
 //#endregion
 //#region src/CodeFlow.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var CodeFlow = class {
-		constructor(options) {
-			this.options = options;
-			this.service = new Gc2Service(options);
-		}
-		async redirectHandle() {
-			const url = window.location.search;
-			const queryParams = new URLSearchParams(url);
-			if (queryParams.get("error")) throw new Error(`Failed to redirect: ${url}`);
-			const code = queryParams.get("code");
-			if (code) {
-				if (queryParams.get("state") !== getStorage().getItem("state")) throw new Error("Possible CSRF attack. Aborting login!");
-				try {
-					const { access_token, refresh_token, id_token } = await this.service.getAuthorizationCodeToken(code, getStorage().getItem("codeVerifier"));
-					setTokens({
-						accessToken: access_token,
-						refreshToken: refresh_token,
-						idToken: id_token
-					});
-					setOptions({
-						clientId: this.options.clientId,
-						host: this.options.host,
-						redirectUri: this.options.redirectUri
-					});
-					getStorage().removeItem("state");
-					getStorage().removeItem("codeVerifier");
-					const params = new URLSearchParams(window.location.search);
-					params.delete("code");
-					params.delete("state");
-					const loc = window.location;
-					const newUrl = loc.origin + loc.pathname + (params.size > 0 ? "?" + params.toString() : "");
-					history.pushState(null, "", newUrl);
-					return Promise.resolve(true);
-				} catch (e) {
-					throw new Error(e.message);
-				}
+var CodeFlow = class {
+	constructor(options) {
+		this.options = options;
+		this.service = new Gc2Service(options);
+	}
+	async redirectHandle() {
+		const url = window.location.search;
+		const queryParams = new URLSearchParams(url);
+		if (queryParams.get("error")) throw new Error(`Failed to redirect: ${url}`);
+		const code = queryParams.get("code");
+		if (code) {
+			if (queryParams.get("state") !== getStorage().getItem("state")) throw new Error("Possible CSRF attack. Aborting login!");
+			try {
+				const { access_token, refresh_token, id_token } = await this.service.getAuthorizationCodeToken(code, getStorage().getItem("codeVerifier"));
+				setTokens({
+					accessToken: access_token,
+					refreshToken: refresh_token,
+					idToken: id_token
+				});
+				setOptions({
+					clientId: this.options.clientId,
+					host: this.options.host,
+					redirectUri: this.options.redirectUri
+				});
+				getStorage().removeItem("state");
+				getStorage().removeItem("codeVerifier");
+				const params = new URLSearchParams(window.location.search);
+				params.delete("code");
+				params.delete("state");
+				const loc = window.location;
+				const newUrl = loc.origin + loc.pathname + (params.size > 0 ? "?" + params.toString() : "");
+				history.pushState(null, "", newUrl);
+				return Promise.resolve(true);
+			} catch (e) {
+				throw new Error(e.message);
 			}
-			return await isLogin(this.service);
-		}
-		async signIn() {
-			const { state, codeVerifier, codeChallenge } = await generatePkceChallenge();
-			getStorage().setItem("state", state);
-			getStorage().setItem("codeVerifier", codeVerifier);
-			window.location.assign(this.service.getAuthorizationCodeURL(codeChallenge, state));
 		}
-		signOut() {
-			this.clear();
-			window.location.assign(this.service.getSignOutURL());
-		}
-		clear() {
-			clearTokens();
-			clearOptions();
-			clearNonce();
-		}
-	};
+		return await isLogin(this.service);
+	}
+	async signIn() {
+		const { state, codeVerifier, codeChallenge } = await generatePkceChallenge();
+		getStorage().setItem("state", state);
+		getStorage().setItem("codeVerifier", codeVerifier);
+		window.location.assign(this.service.getAuthorizationCodeURL(codeChallenge, state));
+	}
+	signOut() {
+		this.clear();
+		window.location.assign(this.service.getSignOutURL());
+	}
+	clear() {
+		clearTokens();
+		clearOptions();
+		clearNonce();
+	}
+};
 
 //#endregion
 //#region src/PasswordFlow.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var PasswordFlow = class {
-		constructor(options) {
-			this.options = options;
-			this.service = new Gc2Service(options);
-		}
-		async signIn() {
-			const { access_token, refresh_token } = await this.service.getPasswordToken();
-			setTokens({
-				accessToken: access_token,
-				refreshToken: refresh_token
-			});
-			setOptions({
-				clientId: this.options.clientId,
-				host: this.options.host,
-				redirectUri: "",
-				clientSecret: this.options.clientSecret
-			});
-		}
-		signOut() {
-			this.clear();
-		}
-		clear() {
-			clearTokens();
-			clearOptions();
-			clearNonce();
-		}
-	};
+var PasswordFlow = class {
+	constructor(options) {
+		this.options = options;
+		this.service = new Gc2Service(options);
+	}
+	async signIn() {
+		const { access_token, refresh_token } = await this.service.getPasswordToken();
+		setTokens({
+			accessToken: access_token,
+			refreshToken: refresh_token
+		});
+		setOptions({
+			clientId: this.options.clientId,
+			host: this.options.host,
+			redirectUri: ""
+		});
+	}
+	signOut() {
+		this.clear();
+	}
+	clear() {
+		clearTokens();
+		clearOptions();
+		clearNonce();
+	}
+};
 
 //#endregion
 //#region src/util/request-headers.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	const getHeaders = async (contentType = "application/json") => {
-		if (!await isLogin(new Gc2Service(getOptions()))) return Promise.reject("Is not logged in");
-		const { accessToken } = getTokens();
-		const headers = {
-			Accept: "application/json",
-			Cookie: "XDEBUG_SESSION=XDEBUG_ECLIPSE",
-			Authorization: accessToken ? "Bearer " + accessToken : null
-		};
-		if (contentType) headers["Content-Type"] = contentType;
-		return headers;
+const getHeaders = async (contentType = "application/json") => {
+	if (!await isLogin(new Gc2Service(getOptions()))) return Promise.reject("Is not logged in");
+	const { accessToken } = getTokens();
+	const headers = {
+		Accept: "application/json",
+		Cookie: "XDEBUG_SESSION=XDEBUG_ECLIPSE",
+		Authorization: accessToken ? "Bearer " + accessToken : null
 	};
-	var request_headers_default = getHeaders;
+	if (contentType) headers["Content-Type"] = contentType;
+	return headers;
+};
+var request_headers_default = getHeaders;
 
 //#endregion
 //#region src/util/make-request.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	const make = async (version, resource, method, payload, contentType = "application/json") => {
-		const options = getOptions();
-		let request = {
-			method,
-			headers: await request_headers_default(contentType),
-			redirect: "manual"
-		};
-		if (payload) request.body = contentType === "application/json" ? JSON.stringify(payload) : payload;
-		if (version !== null) return await fetch(options.host + `/api/v${version}/${resource}`, request);
-		else return await fetch(options.host + `/api/${resource}`, request);
+const make = async (version, resource, method, payload, contentType = "application/json") => {
+	const options = getOptions();
+	let request = {
+		method,
+		headers: await request_headers_default(contentType),
+		redirect: "manual"
 	};
-	var make_request_default = make;
+	if (payload) request.body = contentType === "application/json" ? JSON.stringify(payload) : payload;
+	return await fetch(options.host + `/api/v${version}/${resource}`, request);
+};
+var make_request_default = make;
 
 //#endregion
 //#region src/util/get-response.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	const get = async (response, expectedCode) => {
-		let res = null;
-		let bodyText = "";
-		try {
-			bodyText = await response.text();
-		} catch (e) {}
-		if (bodyText) try {
-			res = JSON.parse(bodyText);
-		} catch (e) {}
-		if (response.status !== expectedCode) {
-			const msg = res && (res.message || res.error) || bodyText || `Unexpected status ${response.status}`;
-			throw new Error(msg);
-		}
-		return res;
-	};
-	var get_response_default = get;
+const get = async (response, expectedCode) => {
+	let res = null;
+	let bodyText = "";
+	try {
+		bodyText = await response.text();
+	} catch (e) {}
+	if (bodyText) try {
+		res = JSON.parse(bodyText);
+	} catch (e) {}
+	if (response.status !== expectedCode) {
+		const msg = res && (res.message || res.error) || bodyText || `Unexpected status ${response.status}`;
+		throw new Error(msg);
+	}
+	return res;
+};
+var get_response_default = get;
 
 //#endregion
 //#region src/Sql.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Sql = class {
-		async exec(request) {
-			return await get_response_default(await make_request_default("4", `sql`, "POST", request), 200);
-		}
-	};
+var Sql = class {
+	async exec(request) {
+		return await get_response_default(await make_request_default("4", `sql`, "POST", request), 200);
+	}
+};
 
 //#endregion
 //#region src/Rpc.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Rpc = class {
-		async call(request) {
-			return await get_response_default(await make_request_default("4", `call`, "POST", request), 200);
-		}
-	};
-
-//#endregion
-//#region src/Gql.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Gql = class {
-		constructor(schema) {
-			this.schema = schema;
-		}
-		async request(request) {
-			return await get_response_default(await make_request_default(null, `graphql/schema/${this.schema}`, "POST", request), 200);
-		}
-	};
+var Rpc = class {
+	async call(request) {
+		return await get_response_default(await make_request_default("4", `call`, "POST", request), 200);
+	}
+};
 
 //#endregion
 //#region src/Meta.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Meta = class {
-		async query(rel) {
-			return await get_response_default(await make_request_default("3", `meta/${rel}`, "GET", null), 200);
-		}
-	};
+var Meta = class {
+	async query(rel) {
+		return await get_response_default(await make_request_default("3", `meta/${rel}`, "GET", null), 200);
+	}
+};
 
 //#endregion
 //#region src/Status.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Status = class {
-		isAuth() {
-			const tokens = getTokens();
-			return !(!tokens.accessToken && !tokens.refreshToken);
-		}
-		getTokens() {
-			return getTokens();
-		}
-	};
+var Status = class {
+	isAuth() {
+		const tokens = getTokens();
+		return !(!tokens.accessToken && !tokens.refreshToken);
+	}
+	getTokens() {
+		return getTokens();
+	}
+};
 
 //#endregion
 //#region src/Claims.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Claims = class {
-		get() {
-			const tokens = getTokens().accessToken;
-			return claims(tokens);
-		}
-	};
+var Claims = class {
+	get() {
+		const tokens = getTokens().accessToken;
+		return claims(tokens);
+	}
+};
 
 //#endregion
 //#region src/Users.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Users = class {
-		async get(user) {
-			return await get_response_default(await make_request_default("4", `users/${user}`, "GET", null), 200);
-		}
-	};
+var Users = class {
+	async get(user) {
+		return await get_response_default(await make_request_default("4", `users/${user}`, "GET", null), 200);
+	}
+};
 
 //#endregion
 //#region src/Ws.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Ws = class {
-		constructor(options) {
-			this.options = options;
-			this.options.wsClient = this.options?.wsClient ?? WebSocket;
-		}
-		connect() {
-			const me = this;
-			const { accessToken } = getTokens();
-			const connect = () => {
-				let queryString = `?token=` + accessToken;
-				if (this.options?.rel) queryString = queryString + `&rel=` + this.options.rel;
-				const WSClass = this.options.wsClient;
-				const ws = new WSClass(this.options.host + `/` + queryString);
-				ws.onopen = function() {
-					console.log("WebSocket connected!");
-				};
-				ws.onmessage = function(event) {
-					me.options.callBack(event.data);
-				};
-				ws.onclose = function(event) {
-					if (accessToken !== "") {
-						console.log("WebSocket closed, reconnecting in 3 seconds...", event.reason);
-						setTimeout(connect, 3e3);
-					}
-				};
-				ws.onerror = function(err) {
-					console.error("WebSocket error observed:", err);
-					ws.close();
-				};
+var Ws = class {
+	constructor(options) {
+		this.options = options;
+		this.options.wsClient = this.options?.wsClient ?? WebSocket;
+	}
+	connect() {
+		const me = this;
+		const { accessToken } = getTokens();
+		const connect = () => {
+			let queryString = `?token=` + accessToken;
+			if (this.options?.rel) queryString = queryString + `&rel=` + this.options.rel;
+			const WSClass = this.options.wsClient;
+			const ws = new WSClass(this.options.host + `/` + queryString);
+			ws.onopen = function() {
+				console.log("WebSocket connected!");
 			};
-			if (accessToken !== "") connect();
-		}
-	};
+			ws.onmessage = function(event) {
+				me.options.callBack(event.data);
+			};
+			ws.onclose = function(event) {
+				if (accessToken !== "") {
+					console.log("WebSocket closed, reconnecting in 3 seconds...", event.reason);
+					setTimeout(connect, 3e3);
+				}
+			};
+			ws.onerror = function(err) {
+				console.error("WebSocket error observed:", err);
+				ws.close();
+			};
+		};
+		if (accessToken !== "") connect();
+	}
+};
 
 //#endregion
 //#region src/Stats.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Stats = class {
-		async get() {
-			return await get_response_default(await make_request_default("4", `stats`, "GET", null), 200);
-		}
-	};
+var Stats = class {
+	async get() {
+		return await get_response_default(await make_request_default("4", `stats`, "GET", null), 200);
+	}
+};
 
 //#endregion
 //#region src/Tables.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var Tables = class {
-		async get(schema, table) {
-			return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "GET", null), 200);
-		}
-		async create(schema, table, payload) {
-			return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "POST", payload), 200);
-		}
-		async patch(schema, table, payload) {
-			return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "PATCH", payload), 200);
-		}
-		async delete(schema, table) {
-			return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "DELETE", null), 204);
-		}
-	};
+var Tables = class {
+	async get(schema, table) {
+		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "GET", null), 200);
+	}
+	async create(schema, table, payload) {
+		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "POST", payload), 200);
+	}
+	async patch(schema, table, payload) {
+		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "PATCH", payload), 200);
+	}
+	async delete(schema, table) {
+		return await get_response_default(await make_request_default("4", `schemas/${encodeURIComponent(schema)}/tables/${encodeURIComponent(table)}`, "DELETE", null), 204);
+	}
+};
 
 //#endregion
 //#region src/Api.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	function isPlainObject$1(v) {
-		return typeof v === "object" && v !== null && !Array.isArray(v);
-	}
-	function validateParamsForMethod(method, params) {
-		if (Array.isArray(params)) {
-			const badIndex = params.findIndex((p) => !isPlainObject$1(p));
-			if (badIndex !== -1) throw new TypeError(`createApi: Invalid argument at index ${badIndex} for RPC method "${method}". Expected a plain object.`);
-			return params;
-		}
-		if (params === void 0) return {};
-		if (!isPlainObject$1(params)) throw new TypeError(`createApi: Invalid argument for RPC method "${method}". Expected a plain object.`);
+function isPlainObject$1(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function validateParamsForMethod(method, params) {
+	if (Array.isArray(params)) {
+		const badIndex = params.findIndex((p) => !isPlainObject$1(p));
+		if (badIndex !== -1) throw new TypeError(`createApi: Invalid argument at index ${badIndex} for RPC method "${method}". Expected a plain object.`);
 		return params;
 	}
-	function extractDataFromResponse(method, res) {
-		if (!res || typeof res !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected an object.`);
-		if (res.jsonrpc !== "2.0") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing or invalid jsonrpc version.`);
-		const err = res.error;
-		if (err !== void 0) {
-			if (!err || typeof err !== "object") throw new TypeError(`createApi: Invalid RPC error for method "${method}". Expected 'error' to be an object.`);
-			const code = err.code;
-			const message = err.message;
-			const data$1 = err.data;
-			const codeIsNum = typeof code === "number" && Number.isFinite(code);
-			const details = typeof message === "string" && message.length > 0 ? message : "Unknown error";
-			const e = /* @__PURE__ */ new Error(`createApi: RPC error for method "${method}"${codeIsNum ? ` (${code})` : ""}: ${details}`);
-			e.code = code;
-			if (data$1 !== void 0) e.data = data$1;
-			e.method = method;
-			e.name = "JsonRpcError";
-			throw e;
-		}
-		const result = res.result;
-		if (!result || typeof result !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing result object.`);
-		const data = result.data;
-		if (!Array.isArray(data)) throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected result.data to be an array.`);
-		return data;
-	}
-	async function dispatch(name, paramsLike) {
-		if (typeof name !== "string" || name.length === 0) throw new TypeError("createApi: RPC method name must be a non-empty string.");
-		const params = validateParamsForMethod(String(name), paramsLike);
-		const rpc = new Rpc();
-		const request = {
-			jsonrpc: "2.0",
-			method: name,
-			id: 1,
-			params
-		};
-		const res = await rpc.call(request);
-		return extractDataFromResponse(String(name), res);
-	}
-	function createApi() {
-		return new Proxy({}, { get(_target, prop) {
-			if (typeof prop !== "string") return void 0;
-			return (...args) => {
-				return dispatch(prop, args.length === 0 ? {} : args.length === 1 ? args[0] : args);
-			};
-		} });
+	if (params === void 0) return {};
+	if (!isPlainObject$1(params)) throw new TypeError(`createApi: Invalid argument for RPC method "${method}". Expected a plain object.`);
+	return params;
+}
+function extractDataFromResponse(method, res) {
+	if (!res || typeof res !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected an object.`);
+	if (res.jsonrpc !== "2.0") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing or invalid jsonrpc version.`);
+	const err = res.error;
+	if (err !== void 0) {
+		if (!err || typeof err !== "object") throw new TypeError(`createApi: Invalid RPC error for method "${method}". Expected 'error' to be an object.`);
+		const code = err.code;
+		const message = err.message;
+		const data$1 = err.data;
+		const codeIsNum = typeof code === "number" && Number.isFinite(code);
+		const details = typeof message === "string" && message.length > 0 ? message : "Unknown error";
+		const e = /* @__PURE__ */ new Error(`createApi: RPC error for method "${method}"${codeIsNum ? ` (${code})` : ""}: ${details}`);
+		e.code = code;
+		if (data$1 !== void 0) e.data = data$1;
+		e.method = method;
+		e.name = "JsonRpcError";
+		throw e;
 	}
+	const result = res.result;
+	if (!result || typeof result !== "object") throw new TypeError(`createApi: Invalid RPC response for method "${method}". Missing result object.`);
+	const data = result.data;
+	if (!Array.isArray(data)) throw new TypeError(`createApi: Invalid RPC response for method "${method}". Expected result.data to be an array.`);
+	return data;
+}
+async function dispatch(name, paramsLike) {
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("createApi: RPC method name must be a non-empty string.");
+	const params = validateParamsForMethod(String(name), paramsLike);
+	const rpc = new Rpc();
+	const request = {
+		jsonrpc: "2.0",
+		method: name,
+		id: 1,
+		params
+	};
+	const res = await rpc.call(request);
+	return extractDataFromResponse(String(name), res);
+}
+function createApi() {
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop !== "string") return void 0;
+		return (...args) => {
+			return dispatch(prop, args.length === 0 ? {} : args.length === 1 ? args[0] : args);
+		};
+	} });
+}
 
 //#endregion
 //#region src/SignUp.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
-	var SignUp = class {
-		constructor(options) {
-			this.options = options;
-			this.service = new Gc2Service(options);
-		}
-		async signUp() {
-			window.location.assign(this.service.getSignUpURL());
-		}
-	};
+var SignUp = class {
+	constructor(options) {
+		this.options = options;
+		this.service = new Gc2Service(options);
+	}
+	async signUp() {
+		window.location.assign(this.service.getSignUpURL());
+	}
+};
 
 //#endregion
 //#region src/SqlBuilder.ts
-	function findTable(schema, name) {
-		const tbl = schema.tables.find((t) => t.name === name);
-		if (!tbl) throw new Error(`Table not found in schema: ${name}`);
-		return tbl;
-	}
-	function findColumn(table, name) {
-		const col = table.columns.find((c) => c.name === name);
-		if (!col) throw new Error(`Column not found in table ${table.name}: ${name}`);
-		return col;
-	}
-	function getPrimaryKeyColumns(table) {
-		const pk = (table.constraints || []).find((c) => c.constraint === "primary" && Array.isArray(c.columns) && c.columns.length > 0);
-		return pk ? pk.columns.map(String) : [];
-	}
-	function typeNameToHint(typname, isArray) {
-		if (!typname) return void 0;
-		const base = typname;
-		return isArray ? base + "[]" : base;
-	}
-	function addTypeHintForParam(typeHints, paramName, col, value) {
-		let isArr = col._is_array;
-		if (Array.isArray(value)) if (isArrayShapedGeomTypename(col._typname)) isArr = value.every(Array.isArray);
-		else isArr = true;
-		const hint = typeNameToHint(col._typname, isArr);
-		if (hint) typeHints[paramName] = hint;
-	}
-	function expectedScalarKind(typname) {
-		const t = typname.toLowerCase();
-		if (t === "int2" || t === "int4" || t === "int8" || t === "float4" || t === "float8") return "number";
-		if (t === "numeric" || t === "decimal") return "string";
-		if (t === "varchar" || t === "text" || t === "bpchar" || t === "char" || t === "date" || t === "time" || t === "timetz" || t === "timestamp" || t === "timestamptz") return "string";
-		if (t === "bool") return "boolean";
-		if (t === "json" || t === "jsonb") return "json";
-		if (t === "int4range" || t === "int8range" || t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "range";
-		if (t === "interval") return "interval";
-		if (t === "point" || t === "line" || t === "lseg" || t === "box" || t === "path" || t === "polygon" || t === "circle") return "geom";
-		return "unknown";
-	}
-	function isArrayShapedGeomTypename(typname) {
-		const t = typname.toLowerCase();
-		return t === "path" || t === "polygon";
-	}
-	function isArrayShapedGeomScalarValue(col, value) {
-		if (!Array.isArray(value)) return false;
-		if (!isArrayShapedGeomTypename(col._typname)) return false;
-		return !value.every(Array.isArray);
-	}
-	function expectedRangeInnerKind(typname) {
-		const t = typname.toLowerCase();
-		if (t === "int4range" || t === "int8range") return "number";
-		if (t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "string";
-		return "unknown";
-	}
-	function isPlainObject(v) {
-		return typeof v === "object" && v !== null && !Array.isArray(v);
-	}
-	function isFiniteNumber(n) {
-		return typeof n === "number" && Number.isFinite(n);
-	}
-	function isPointLike(v) {
-		if (!isPlainObject(v)) return false;
-		const x = v.x;
-		const y = v.y;
-		return isFiniteNumber(x) && isFiniteNumber(y);
-	}
-	function validateGeometryForColumn(col, value, context) {
-		const t = col._typname.toLowerCase();
-		if (t === "point") {
-			if (!isPointLike(value)) throw new Error(`Invalid value for ${context}. Expected Point { x: number, y: number }`);
-			return;
-		}
-		if (t === "line") {
-			if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Line { A: number, B: number, C: number }`);
-			const A = value.A, B = value.B, C = value.C;
-			if (!isFiniteNumber(A) || !isFiniteNumber(B) || !isFiniteNumber(C)) throw new Error(`Invalid Line for ${context}. A, B, C must be finite numbers`);
-			return;
-		}
-		if (t === "lseg" || t === "box") {
-			if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected ${t.toUpperCase()} { start: Point, end: Point }`);
-			const start = value.start;
-			const end = value.end;
-			if (!isPointLike(start) || !isPointLike(end)) throw new Error(`Invalid ${t} for ${context}. 'start' and 'end' must be Point { x, y }`);
-			return;
-		}
-		if (t === "path") {
-			if (!Array.isArray(value) || value.length < 1) throw new Error(`Invalid value for ${context}. Expected Path [isClosed: boolean, ...points: Point[]]`);
-			const [isClosed, ...points] = value;
-			if (typeof isClosed !== "boolean") throw new Error(`Invalid Path for ${context}. First element must be boolean (isClosed)`);
-			for (let i = 0; i < points.length; i++) if (!isPointLike(points[i])) throw new Error(`Invalid Path for ${context}. Element at index ${i + 1} must be Point { x, y }`);
-			return;
-		}
-		if (t === "polygon") {
-			if (!Array.isArray(value)) throw new Error(`Invalid value for ${context}. Expected Polygon as Point[]`);
-			for (let i = 0; i < value.length; i++) if (!isPointLike(value[i])) throw new Error(`Invalid Polygon for ${context}. Element at index ${i} must be Point { x, y }`);
-			return;
-		}
-		if (t === "circle") {
-			if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Circle { center: Point, radius: number }`);
-			const center = value.center;
-			const radius = value.radius;
-			if (!isPointLike(center) || !isFiniteNumber(radius)) throw new Error(`Invalid Circle for ${context}. 'center' must be Point and 'radius' must be finite number`);
-			return;
-		}
+function findTable(schema, name) {
+	const tbl = schema.tables.find((t) => t.name === name);
+	if (!tbl) throw new Error(`Table not found in schema: ${name}`);
+	return tbl;
+}
+function findColumn(table, name) {
+	const col = table.columns.find((c) => c.name === name);
+	if (!col) throw new Error(`Column not found in table ${table.name}: ${name}`);
+	return col;
+}
+function getPrimaryKeyColumns(table) {
+	const pk = (table.constraints || []).find((c) => c.constraint === "primary" && Array.isArray(c.columns) && c.columns.length > 0);
+	return pk ? pk.columns.map(String) : [];
+}
+function typeNameToHint(typname, isArray) {
+	if (!typname) return void 0;
+	const base = typname;
+	return isArray ? base + "[]" : base;
+}
+function addTypeHintForParam(typeHints, paramName, col, value) {
+	let isArr = col._is_array;
+	if (Array.isArray(value)) if (isArrayShapedGeomTypename(col._typname)) isArr = value.every(Array.isArray);
+	else isArr = true;
+	const hint = typeNameToHint(col._typname, isArr);
+	if (hint) typeHints[paramName] = hint;
+}
+function expectedScalarKind(typname) {
+	const t = typname.toLowerCase();
+	if (t === "int2" || t === "int4" || t === "int8" || t === "float4" || t === "float8") return "number";
+	if (t === "numeric" || t === "decimal") return "string";
+	if (t === "varchar" || t === "text" || t === "bpchar" || t === "char" || t === "date" || t === "time" || t === "timetz" || t === "timestamp" || t === "timestamptz") return "string";
+	if (t === "bool") return "boolean";
+	if (t === "json" || t === "jsonb") return "json";
+	if (t === "int4range" || t === "int8range" || t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "range";
+	if (t === "interval") return "interval";
+	if (t === "point" || t === "line" || t === "lseg" || t === "box" || t === "path" || t === "polygon" || t === "circle") return "geom";
+	return "unknown";
+}
+function isArrayShapedGeomTypename(typname) {
+	const t = typname.toLowerCase();
+	return t === "path" || t === "polygon";
+}
+function isArrayShapedGeomScalarValue(col, value) {
+	if (!Array.isArray(value)) return false;
+	if (!isArrayShapedGeomTypename(col._typname)) return false;
+	return !value.every(Array.isArray);
+}
+function expectedRangeInnerKind(typname) {
+	const t = typname.toLowerCase();
+	if (t === "int4range" || t === "int8range") return "number";
+	if (t === "numrange" || t === "tsrange" || t === "tstzrange" || t === "daterange") return "string";
+	return "unknown";
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isFiniteNumber(n) {
+	return typeof n === "number" && Number.isFinite(n);
+}
+function isPointLike(v) {
+	if (!isPlainObject(v)) return false;
+	const x = v.x;
+	const y = v.y;
+	return isFiniteNumber(x) && isFiniteNumber(y);
+}
+function validateGeometryForColumn(col, value, context) {
+	const t = col._typname.toLowerCase();
+	if (t === "point") {
+		if (!isPointLike(value)) throw new Error(`Invalid value for ${context}. Expected Point { x: number, y: number }`);
+		return;
 	}
-	function validateRangeForColumn(col, value, context) {
-		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected a range object for type ${col._typname}`);
-		const r = value;
-		const hasLower = Object.prototype.hasOwnProperty.call(r, "lower");
-		const hasUpper = Object.prototype.hasOwnProperty.call(r, "upper");
-		const hasLi = Object.prototype.hasOwnProperty.call(r, "lowerInclusive");
-		const hasUi = Object.prototype.hasOwnProperty.call(r, "upperInclusive");
-		if (!hasLower || !hasUpper || !hasLi || !hasUi) throw new Error(`Invalid range for ${context}. Required properties: lower, upper, lowerInclusive, upperInclusive`);
-		if (typeof r.lowerInclusive !== "boolean" || typeof r.upperInclusive !== "boolean") throw new Error(`Invalid range for ${context}. lowerInclusive and upperInclusive must be boolean`);
-		const inner = expectedRangeInnerKind(col._typname);
-		if (inner === "number") {
-			if (typeof r.lower !== "number" || !Number.isFinite(r.lower)) throw new Error(`Invalid range.lower for ${context}. Expected number for type ${col._typname}`);
-			if (typeof r.upper !== "number" || !Number.isFinite(r.upper)) throw new Error(`Invalid range.upper for ${context}. Expected number for type ${col._typname}`);
-		} else if (inner === "string") {
-			if (typeof r.lower !== "string") throw new Error(`Invalid range.lower for ${context}. Expected string for type ${col._typname}`);
-			if (typeof r.upper !== "string") throw new Error(`Invalid range.upper for ${context}. Expected string for type ${col._typname}`);
-		}
+	if (t === "line") {
+		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Line { A: number, B: number, C: number }`);
+		const A = value.A, B = value.B, C = value.C;
+		if (!isFiniteNumber(A) || !isFiniteNumber(B) || !isFiniteNumber(C)) throw new Error(`Invalid Line for ${context}. A, B, C must be finite numbers`);
+		return;
 	}
-	function validateIntervalForColumn(col, value, context) {
-		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected an interval object for type ${col._typname}`);
-		const v = value;
-		for (const k of [
-			"y",
-			"m",
-			"d",
-			"h",
-			"i",
-			"s"
-		]) {
-			if (!Object.prototype.hasOwnProperty.call(v, k)) throw new Error(`Invalid interval for ${context}. Missing property '${k}'`);
-			const num = v[k];
-			if (typeof num !== "number" || !Number.isFinite(num)) throw new Error(`Invalid interval.${String(k)} for ${context}. Expected finite number`);
-		}
+	if (t === "lseg" || t === "box") {
+		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected ${t.toUpperCase()} { start: Point, end: Point }`);
+		const start = value.start;
+		const end = value.end;
+		if (!isPointLike(start) || !isPointLike(end)) throw new Error(`Invalid ${t} for ${context}. 'start' and 'end' must be Point { x, y }`);
+		return;
 	}
-	function isValidJsonLike(value) {
-		return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "object" && value !== null;
+	if (t === "path") {
+		if (!Array.isArray(value) || value.length < 1) throw new Error(`Invalid value for ${context}. Expected Path [isClosed: boolean, ...points: Point[]]`);
+		const [isClosed, ...points] = value;
+		if (typeof isClosed !== "boolean") throw new Error(`Invalid Path for ${context}. First element must be boolean (isClosed)`);
+		for (let i = 0; i < points.length; i++) if (!isPointLike(points[i])) throw new Error(`Invalid Path for ${context}. Element at index ${i + 1} must be Point { x, y }`);
+		return;
 	}
-	function validateScalarForColumn(col, value, context) {
-		const kind = expectedScalarKind(col._typname);
-		if (kind === "unknown") return;
-		if (kind === "number") {
-			if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Invalid value for ${context}. Expected number for type ${col._typname}, got ${typeof value}`);
-			return;
-		}
-		if (kind === "string") {
-			if (typeof value !== "string") throw new Error(`Invalid value for ${context}. Expected string for type ${col._typname}, got ${typeof value}`);
-			return;
-		}
-		if (kind === "boolean") {
-			if (typeof value !== "boolean") throw new Error(`Invalid value for ${context}. Expected boolean for type ${col._typname}, got ${typeof value}`);
-			return;
-		}
-		if (kind === "json") {
-			if (!isValidJsonLike(value)) throw new Error(`Invalid value for ${context}. Expected JSON-compatible value for type ${col._typname}`);
-			return;
-		}
-		if (kind === "range") {
-			validateRangeForColumn(col, value, context);
-			return;
-		}
-		if (kind === "interval") {
-			validateIntervalForColumn(col, value, context);
-			return;
-		}
-		if (kind === "geom") {
-			validateGeometryForColumn(col, value, context);
-			return;
-		}
+	if (t === "polygon") {
+		if (!Array.isArray(value)) throw new Error(`Invalid value for ${context}. Expected Polygon as Point[]`);
+		for (let i = 0; i < value.length; i++) if (!isPointLike(value[i])) throw new Error(`Invalid Polygon for ${context}. Element at index ${i} must be Point { x, y }`);
+		return;
 	}
-	function validateComparisonValue(col, key, value, op) {
-		if (value === void 0 || value === null) throw new Error(`Operator ${op} on column ${key} requires a non-null value. Use isnull/notnull for null checks.`);
-		if (col._is_array) {
-			if (!Array.isArray(value)) throw new Error(`Operator ${op} on array column ${key} requires an array value`);
-			for (const [i, v] of value.entries()) validateScalarForColumn(col, v, `column ${key}[${i}]`);
-		} else {
-			if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) throw new Error(`Operator ${op} on scalar column ${key} cannot accept an array value`);
-			validateScalarForColumn(col, value, `column ${key}`);
-		}
+	if (t === "circle") {
+		if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected Circle { center: Point, radius: number }`);
+		const center = value.center;
+		const radius = value.radius;
+		if (!isPointLike(center) || !isFiniteNumber(radius)) throw new Error(`Invalid Circle for ${context}. 'center' must be Point and 'radius' must be finite number`);
+		return;
 	}
-	function validateInArrayValues(col, key, values, op) {
-		if (!col._is_array) {
-			let idx = 0;
-			for (const v of values) {
-				validateScalarForColumn(col, v, `column ${key} (element ${idx})`);
-				idx++;
-			}
-		}
+}
+function validateRangeForColumn(col, value, context) {
+	if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected a range object for type ${col._typname}`);
+	const r = value;
+	const hasLower = Object.prototype.hasOwnProperty.call(r, "lower");
+	const hasUpper = Object.prototype.hasOwnProperty.call(r, "upper");
+	const hasLi = Object.prototype.hasOwnProperty.call(r, "lowerInclusive");
+	const hasUi = Object.prototype.hasOwnProperty.call(r, "upperInclusive");
+	if (!hasLower || !hasUpper || !hasLi || !hasUi) throw new Error(`Invalid range for ${context}. Required properties: lower, upper, lowerInclusive, upperInclusive`);
+	if (typeof r.lowerInclusive !== "boolean" || typeof r.upperInclusive !== "boolean") throw new Error(`Invalid range for ${context}. lowerInclusive and upperInclusive must be boolean`);
+	const inner = expectedRangeInnerKind(col._typname);
+	if (inner === "number") {
+		if (typeof r.lower !== "number" || !Number.isFinite(r.lower)) throw new Error(`Invalid range.lower for ${context}. Expected number for type ${col._typname}`);
+		if (typeof r.upper !== "number" || !Number.isFinite(r.upper)) throw new Error(`Invalid range.upper for ${context}. Expected number for type ${col._typname}`);
+	} else if (inner === "string") {
+		if (typeof r.lower !== "string") throw new Error(`Invalid range.lower for ${context}. Expected string for type ${col._typname}`);
+		if (typeof r.upper !== "string") throw new Error(`Invalid range.upper for ${context}. Expected string for type ${col._typname}`);
+	}
+}
+function validateIntervalForColumn(col, value, context) {
+	if (!isPlainObject(value)) throw new Error(`Invalid value for ${context}. Expected an interval object for type ${col._typname}`);
+	const v = value;
+	for (const k of [
+		"y",
+		"m",
+		"d",
+		"h",
+		"i",
+		"s"
+	]) {
+		if (!Object.prototype.hasOwnProperty.call(v, k)) throw new Error(`Invalid interval for ${context}. Missing property '${k}'`);
+		const num = v[k];
+		if (typeof num !== "number" || !Number.isFinite(num)) throw new Error(`Invalid interval.${String(k)} for ${context}. Expected finite number`);
+	}
+}
+function isValidJsonLike(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "object" && value !== null;
+}
+function validateScalarForColumn(col, value, context) {
+	const kind = expectedScalarKind(col._typname);
+	if (kind === "unknown") return;
+	if (kind === "number") {
+		if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Invalid value for ${context}. Expected number for type ${col._typname}, got ${typeof value}`);
+		return;
 	}
-	function findJoinOn(base, target) {
-		const bc = base.constraints || [];
-		const tc = target.constraints || [];
-		for (const c of bc) if (c.constraint === "foreign" && c.referenced_table === target.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.columns.map((col, i) => ({
-			left: String(col),
-			right: String(c.referenced_columns[i])
-		}));
-		for (const c of tc) if (c.constraint === "foreign" && c.referenced_table === base.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.referenced_columns.map((rcol, i) => ({
-			left: String(rcol),
-			right: String(c.columns[i])
-		}));
-		return null;
-	}
-	var TableQueryImpl = class {
-		constructor(schema, tableName) {
-			this.schema = schema;
-			this.table = findTable(schema, tableName);
+	if (kind === "string") {
+		if (typeof value !== "string") throw new Error(`Invalid value for ${context}. Expected string for type ${col._typname}, got ${typeof value}`);
+		return;
+	}
+	if (kind === "boolean") {
+		if (typeof value !== "boolean") throw new Error(`Invalid value for ${context}. Expected boolean for type ${col._typname}, got ${typeof value}`);
+		return;
+	}
+	if (kind === "json") {
+		if (!isValidJsonLike(value)) throw new Error(`Invalid value for ${context}. Expected JSON-compatible value for type ${col._typname}`);
+		return;
+	}
+	if (kind === "range") {
+		validateRangeForColumn(col, value, context);
+		return;
+	}
+	if (kind === "interval") {
+		validateIntervalForColumn(col, value, context);
+		return;
+	}
+	if (kind === "geom") {
+		validateGeometryForColumn(col, value, context);
+		return;
+	}
+}
+function validateComparisonValue(col, key, value, op) {
+	if (value === void 0 || value === null) throw new Error(`Operator ${op} on column ${key} requires a non-null value. Use isnull/notnull for null checks.`);
+	if (col._is_array) {
+		if (!Array.isArray(value)) throw new Error(`Operator ${op} on array column ${key} requires an array value`);
+		for (const [i, v] of value.entries()) validateScalarForColumn(col, v, `column ${key}[${i}]`);
+	} else {
+		if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) throw new Error(`Operator ${op} on scalar column ${key} cannot accept an array value`);
+		validateScalarForColumn(col, value, `column ${key}`);
+	}
+}
+function validateInArrayValues(col, key, values, op) {
+	if (!col._is_array) {
+		let idx = 0;
+		for (const v of values) {
+			validateScalarForColumn(col, v, `column ${key} (element ${idx})`);
+			idx++;
 		}
-		select(cols) {
-			const table = this.table;
-			const schema = this.schema;
-			const selected = cols && cols.length ? cols : ["*"];
-			const state = {
-				table,
-				selected,
-				where: {},
-				orWhereGroups: [],
-				andOps: [],
-				orOpGroups: [],
-				order: [],
-				limit: void 0,
-				offset: void 0,
-				joins: [],
-				joinSelections: []
-			};
-			return new class {
-				constructor() {
-					this.s = state;
-					this.toSql = () => {
-						const params = {};
-						const type_hints = {};
-						let p = 0;
-						const parts = [];
-						const selectParts = [];
-						if (selected.length === 1 && selected[0] === "*") selectParts.push(`"${table.name}".*`);
-						else {
-							const sel = selected;
-							for (const c of sel) findColumn(table, String(c));
-							selectParts.push(sel.map((c) => `"${table.name}"."${c}"`).join(", "));
-						}
-						for (const js of state.joinSelections) if (js.selected.length === 1 && js.selected[0] === "*") selectParts.push(`"${js.target.name}".*`);
-						else {
-							const cols$1 = js.selected;
-							for (const c of cols$1) findColumn(js.target, String(c));
-							selectParts.push(cols$1.map((c) => `"${js.target.name}"."${c}"`).join(", "));
+	}
+}
+function findJoinOn(base, target) {
+	const bc = base.constraints || [];
+	const tc = target.constraints || [];
+	for (const c of bc) if (c.constraint === "foreign" && c.referenced_table === target.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.columns.map((col, i) => ({
+		left: String(col),
+		right: String(c.referenced_columns[i])
+	}));
+	for (const c of tc) if (c.constraint === "foreign" && c.referenced_table === base.name && c.columns?.length && c.referenced_columns?.length && c.columns.length === c.referenced_columns.length) return c.referenced_columns.map((rcol, i) => ({
+		left: String(rcol),
+		right: String(c.columns[i])
+	}));
+	return null;
+}
+var TableQueryImpl = class {
+	constructor(schema, tableName) {
+		this.schema = schema;
+		this.table = findTable(schema, tableName);
+	}
+	select(cols) {
+		const table = this.table;
+		const schema = this.schema;
+		const selected = cols && cols.length ? cols : ["*"];
+		const state = {
+			table,
+			selected,
+			where: {},
+			orWhereGroups: [],
+			andOps: [],
+			orOpGroups: [],
+			order: [],
+			limit: void 0,
+			offset: void 0,
+			joins: [],
+			joinSelections: []
+		};
+		return new class {
+			constructor() {
+				this.s = state;
+				this.toSql = () => {
+					const params = {};
+					const type_hints = {};
+					let p = 0;
+					const parts = [];
+					const selectParts = [];
+					if (selected.length === 1 && selected[0] === "*") selectParts.push(`"${table.name}".*`);
+					else {
+						const sel = selected;
+						for (const c of sel) findColumn(table, String(c));
+						selectParts.push(sel.map((c) => `"${table.name}"."${c}"`).join(", "));
+					}
+					for (const js of state.joinSelections) if (js.selected.length === 1 && js.selected[0] === "*") selectParts.push(`"${js.target.name}".*`);
+					else {
+						const cols$1 = js.selected;
+						for (const c of cols$1) findColumn(js.target, String(c));
+						selectParts.push(cols$1.map((c) => `"${js.target.name}"."${c}"`).join(", "));
+					}
+					parts.push(`select ${selectParts.join(", ")} from "${schema.name}"."${table.name}"`);
+					for (const j of state.joins) {
+						const onExpr = j.on.map((p$1) => `"${j.source.name}"."${p$1.left}" = "${j.target.name}"."${p$1.right}"`).join(" and ");
+						parts.push(`${j.type} join "${schema.name}"."${j.target.name}" on ${onExpr}`);
+					}
+					const andParts = [];
+					for (const key in state.where) {
+						const value = state.where[key];
+						const col = findColumn(table, key);
+						p += 1;
+						const paramName = `${table.name}_${key}_${p}`;
+						if (value === null) {
+							if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+							andParts.push(`"${table.name}"."${key}" is null`);
+						} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
+							validateInArrayValues(col, key, value, "in");
+							andParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
+						} else {
+							validateScalarForColumn(col, value, `column ${key}`);
+							andParts.push(`"${table.name}"."${key}" = :${paramName}`);
+							params[paramName] = value;
+							addTypeHintForParam(type_hints, paramName, col, value);
 						}
-						parts.push(`select ${selectParts.join(", ")} from "${schema.name}"."${table.name}"`);
-						for (const j of state.joins) {
-							const onExpr = j.on.map((p$1) => `"${j.source.name}"."${p$1.left}" = "${j.target.name}"."${p$1.right}"`).join(" and ");
-							parts.push(`${j.type} join "${schema.name}"."${j.target.name}" on ${onExpr}`);
+					}
+					for (const pred of state.andOps) {
+						const key = String(pred.col);
+						const op = String(pred.op);
+						const col = findColumn(table, key);
+						const qualified = `"${table.name}"."${key}"`;
+						if (op === "isnull" || op === "notnull") {
+							if (pred.value !== void 0) throw new Error(`Operator ${op} does not take a value for column ${key}`);
+							andParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
+						} else if (op === "in" || op === "notin") {
+							const val = pred.value;
+							if (!Array.isArray(val)) throw new Error(`Operator ${op} requires an array value for column ${key}`);
+							validateInArrayValues(col, key, val, op);
+							p += 1;
+							const paramName = `${table.name}_${key}_${p}`;
+							andParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
+							params[paramName] = val;
+							addTypeHintForParam(type_hints, paramName, col, val);
+						} else if (op === "like" || op === "ilike" || op === "notlike" || op === "notilike") {
+							const val = pred.value;
+							if (typeof val !== "string") throw new Error(`Operator ${op} requires a string value for column ${key}`);
+							p += 1;
+							const paramName = `${table.name}_${key}_${p}`;
+							const sqlOp = op === "like" ? "like" : op === "ilike" ? "ilike" : op === "notlike" ? "not like" : "not ilike";
+							andParts.push(`${qualified} ${sqlOp} :${paramName}`);
+							params[paramName] = val;
+							addTypeHintForParam(type_hints, paramName, col, val);
+						} else {
+							const val = pred.value;
+							if (val === void 0) throw new Error(`Operator ${op} requires a value for column ${key}`);
+							validateComparisonValue(col, key, val, op);
+							p += 1;
+							const paramName = `${table.name}_${key}_${p}`;
+							if (op === "=") andParts.push(`${qualified} = :${paramName}`);
+							else if (op === "!=") andParts.push(`${qualified} <> :${paramName}`);
+							else if (op === "<" || op === "<=" || op === ">" || op === ">=") andParts.push(`${qualified} ${op} :${paramName}`);
+							else throw new Error(`Unsupported operator: ${op}`);
+							params[paramName] = val;
+							addTypeHintForParam(type_hints, paramName, col, val);
 						}
-						const andParts = [];
-						for (const key in state.where) {
-							const value = state.where[key];
+					}
+					const orGroupSql = [];
+					for (const group of state.orWhereGroups) {
+						const orParts = [];
+						for (const key in group) {
+							const value = group[key];
 							const col = findColumn(table, key);
 							p += 1;
 							const paramName = `${table.name}_${key}_${p}`;
 							if (value === null) {
 								if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
-								andParts.push(`"${table.name}"."${key}" is null`);
+								orParts.push(`"${table.name}"."${key}" is null`);
 							} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
 								validateInArrayValues(col, key, value, "in");
-								andParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
+								orParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
 								params[paramName] = value;
 								addTypeHintForParam(type_hints, paramName, col, value);
 							} else {
 								validateScalarForColumn(col, value, `column ${key}`);
-								andParts.push(`"${table.name}"."${key}" = :${paramName}`);
+								orParts.push(`"${table.name}"."${key}" = :${paramName}`);
 								params[paramName] = value;
 								addTypeHintForParam(type_hints, paramName, col, value);
 							}
 						}
-						for (const pred of state.andOps) {
+						if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
+					}
+					for (const group of state.orOpGroups) {
+						const orParts = [];
+						for (const pred of group) {
 							const key = String(pred.col);
 							const op = String(pred.op);
 							const col = findColumn(table, key);
 							const qualified = `"${table.name}"."${key}"`;
 							if (op === "isnull" || op === "notnull") {
 								if (pred.value !== void 0) throw new Error(`Operator ${op} does not take a value for column ${key}`);
-								andParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
+								orParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
 							} else if (op === "in" || op === "notin") {
 								const val = pred.value;
 								if (!Array.isArray(val)) throw new Error(`Operator ${op} requires an array value for column ${key}`);
 								validateInArrayValues(col, key, val, op);
 								p += 1;
 								const paramName = `${table.name}_${key}_${p}`;
-								andParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
+								orParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
 								params[paramName] = val;
 								addTypeHintForParam(type_hints, paramName, col, val);
 							} else if (op === "like" || op === "ilike" || op === "notlike" || op === "notilike") {
@@ -1075,7 +1014,7 @@
 								p += 1;
 								const paramName = `${table.name}_${key}_${p}`;
 								const sqlOp = op === "like" ? "like" : op === "ilike" ? "ilike" : op === "notlike" ? "not like" : "not ilike";
-								andParts.push(`${qualified} ${sqlOp} :${paramName}`);
+								orParts.push(`${qualified} ${sqlOp} :${paramName}`);
 								params[paramName] = val;
 								addTypeHintForParam(type_hints, paramName, col, val);
 							} else {
@@ -1084,137 +1023,252 @@
 								validateComparisonValue(col, key, val, op);
 								p += 1;
 								const paramName = `${table.name}_${key}_${p}`;
-								if (op === "=") andParts.push(`${qualified} = :${paramName}`);
-								else if (op === "!=") andParts.push(`${qualified} <> :${paramName}`);
-								else if (op === "<" || op === "<=" || op === ">" || op === ">=") andParts.push(`${qualified} ${op} :${paramName}`);
+								if (op === "=") orParts.push(`${qualified} = :${paramName}`);
+								else if (op === "!=") orParts.push(`${qualified} <> :${paramName}`);
+								else if (op === "<" || op === "<=" || op === ">" || op === ">=") orParts.push(`${qualified} ${op} :${paramName}`);
 								else throw new Error(`Unsupported operator: ${op}`);
 								params[paramName] = val;
 								addTypeHintForParam(type_hints, paramName, col, val);
 							}
 						}
-						const orGroupSql = [];
-						for (const group of state.orWhereGroups) {
-							const orParts = [];
-							for (const key in group) {
-								const value = group[key];
-								const col = findColumn(table, key);
-								p += 1;
-								const paramName = `${table.name}_${key}_${p}`;
-								if (value === null) {
-									if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
-									orParts.push(`"${table.name}"."${key}" is null`);
-								} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
-									validateInArrayValues(col, key, value, "in");
-									orParts.push(`"${table.name}"."${key}" = ANY(:${paramName})`);
-									params[paramName] = value;
-									addTypeHintForParam(type_hints, paramName, col, value);
-								} else {
-									validateScalarForColumn(col, value, `column ${key}`);
-									orParts.push(`"${table.name}"."${key}" = :${paramName}`);
-									params[paramName] = value;
-									addTypeHintForParam(type_hints, paramName, col, value);
-								}
-							}
-							if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
-						}
-						for (const group of state.orOpGroups) {
-							const orParts = [];
-							for (const pred of group) {
-								const key = String(pred.col);
-								const op = String(pred.op);
-								const col = findColumn(table, key);
-								const qualified = `"${table.name}"."${key}"`;
-								if (op === "isnull" || op === "notnull") {
-									if (pred.value !== void 0) throw new Error(`Operator ${op} does not take a value for column ${key}`);
-									orParts.push(`${qualified} is ${op === "isnull" ? "null" : "not null"}`);
-								} else if (op === "in" || op === "notin") {
-									const val = pred.value;
-									if (!Array.isArray(val)) throw new Error(`Operator ${op} requires an array value for column ${key}`);
-									validateInArrayValues(col, key, val, op);
-									p += 1;
-									const paramName = `${table.name}_${key}_${p}`;
-									orParts.push(`${qualified} ${op === "in" ? "= ANY" : "!= ALL"}(:${paramName})`);
-									params[paramName] = val;
-									addTypeHintForParam(type_hints, paramName, col, val);
-								} else if (op === "like" || op === "ilike" || op === "notlike" || op === "notilike") {
-									const val = pred.value;
-									if (typeof val !== "string") throw new Error(`Operator ${op} requires a string value for column ${key}`);
-									p += 1;
-									const paramName = `${table.name}_${key}_${p}`;
-									const sqlOp = op === "like" ? "like" : op === "ilike" ? "ilike" : op === "notlike" ? "not like" : "not ilike";
-									orParts.push(`${qualified} ${sqlOp} :${paramName}`);
-									params[paramName] = val;
-									addTypeHintForParam(type_hints, paramName, col, val);
-								} else {
-									const val = pred.value;
-									if (val === void 0) throw new Error(`Operator ${op} requires a value for column ${key}`);
-									validateComparisonValue(col, key, val, op);
-									p += 1;
-									const paramName = `${table.name}_${key}_${p}`;
-									if (op === "=") orParts.push(`${qualified} = :${paramName}`);
-									else if (op === "!=") orParts.push(`${qualified} <> :${paramName}`);
-									else if (op === "<" || op === "<=" || op === ">" || op === ">=") orParts.push(`${qualified} ${op} :${paramName}`);
-									else throw new Error(`Unsupported operator: ${op}`);
-									params[paramName] = val;
-									addTypeHintForParam(type_hints, paramName, col, val);
-								}
-							}
-							if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
-						}
-						if (orGroupSql.length) {
-							const andSql = andParts.length ? `(${andParts.join(" and ")})` : "";
-							const orSql = orGroupSql.join(" or ");
-							const full = andSql ? `${andSql} or ${orSql}` : orSql;
-							if (full.trim().length) parts.push("where " + full);
-						} else if (andParts.length) parts.push("where " + andParts.join(" and "));
-						if (state.order.length) {
-							const orders = [];
-							for (const o of state.order) orders.push(`"${table.name}"."${o.col}" ${o.dir}`);
-							parts.push("order by " + orders.join(", "));
-						}
-						if (state.limit !== void 0) parts.push("limit " + state.limit);
-						if (state.offset !== void 0) parts.push("offset " + state.offset);
-						return {
-							q: parts.join(" "),
-							params: Object.keys(params).length > 0 ? params : void 0,
-							type_hints: Object.keys(type_hints).length ? type_hints : void 0
-						};
+						if (orParts.length) orGroupSql.push("(" + orParts.join(" or ") + ")");
+					}
+					if (orGroupSql.length) {
+						const andSql = andParts.length ? `(${andParts.join(" and ")})` : "";
+						const orSql = orGroupSql.join(" or ");
+						const full = andSql ? `${andSql} or ${orSql}` : orSql;
+						if (full.trim().length) parts.push("where " + full);
+					} else if (andParts.length) parts.push("where " + andParts.join(" and "));
+					if (state.order.length) {
+						const orders = [];
+						for (const o of state.order) orders.push(`"${table.name}"."${o.col}" ${o.dir}`);
+						parts.push("order by " + orders.join(", "));
+					}
+					if (state.limit !== void 0) parts.push("limit " + state.limit);
+					if (state.offset !== void 0) parts.push("offset " + state.offset);
+					return {
+						q: parts.join(" "),
+						params: Object.keys(params).length > 0 ? params : void 0,
+						type_hints: Object.keys(type_hints).length ? type_hints : void 0
 					};
+				};
+			}
+			selectFrom(tableName, cols$1) {
+				const jtName = String(tableName);
+				const join = this.s.joins.find((j) => j.target.name === jtName);
+				if (!join) throw new Error(`selectFrom('${jtName}') requires a prior join('${jtName}') call`);
+				const sel = !cols$1 || cols$1.length === 0 ? ["*"] : cols$1.map(String);
+				if (!(sel.length === 1 && sel[0] === "*")) for (const c of sel) findColumn(join.target, String(c));
+				const existing = this.s.joinSelections.find((js) => js.target.name === jtName);
+				if (existing) {
+					if (existing.selected.includes("*")) return this;
+					if (sel.length === 1 && sel[0] === "*") existing.selected = ["*"];
+					else {
+						const set = new Set(existing.selected);
+						for (const c of sel) set.add(String(c));
+						existing.selected = Array.from(set);
+					}
+				} else this.s.joinSelections.push({
+					target: join.target,
+					selected: sel
+				});
+				return this;
+			}
+			andWhere(where) {
+				for (const k in where) this.s.where[k] = where[k];
+				return this;
+			}
+			/** @deprecated Use andWhere() instead */
+			where(where) {
+				return this.andWhere(where);
+			}
+			orWhere(where) {
+				this.s.orWhereGroups.push(where);
+				return this;
+			}
+			wherePk(pk) {
+				const pkCols = getPrimaryKeyColumns(table);
+				if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
+				if (pkCols.length === 1) {
+					const colName = pkCols[0];
+					const colDef = findColumn(table, colName);
+					if (pk === null || pk === void 0) throw new Error(`wherePk on ${table.name} requires a non-null value for primary key column ${colName}`);
+					if (Array.isArray(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}, not an array`);
+					if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}`);
+					validateScalarForColumn(colDef, pk, `primary key ${table.name}.${colName}`);
+					this.s.where[colName] = pk;
+					return this;
+				} else {
+					if (!isPlainObject(pk) || pk === null) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
+					const obj = pk;
+					for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
+					for (const colName of pkCols) {
+						if (!(colName in obj)) throw new Error(`wherePk missing key '${colName}'. Required keys: ${pkCols.join(", ")}`);
+						const v = obj[colName];
+						if (v === null || v === void 0) throw new Error(`wherePk on ${table.name} requires non-null values for all primary key columns (${pkCols.join(", ")})`);
+						if (Array.isArray(v)) throw new Error(`wherePk on ${table.name} expects scalar values for primary key column ${colName}, not an array`);
+						validateScalarForColumn(findColumn(table, colName), v, `primary key ${table.name}.${colName}`);
+						this.s.where[colName] = v;
+					}
+					return this;
 				}
-				selectFrom(tableName, cols$1) {
-					const jtName = String(tableName);
-					const join = this.s.joins.find((j) => j.target.name === jtName);
-					if (!join) throw new Error(`selectFrom('${jtName}') requires a prior join('${jtName}') call`);
-					const sel = !cols$1 || cols$1.length === 0 ? ["*"] : cols$1.map(String);
-					if (!(sel.length === 1 && sel[0] === "*")) for (const c of sel) findColumn(join.target, String(c));
-					const existing = this.s.joinSelections.find((js) => js.target.name === jtName);
-					if (existing) {
-						if (existing.selected.includes("*")) return this;
-						if (sel.length === 1 && sel[0] === "*") existing.selected = ["*"];
-						else {
-							const set = new Set(existing.selected);
-							for (const c of sel) set.add(String(c));
-							existing.selected = Array.from(set);
-						}
-					} else this.s.joinSelections.push({
-						target: join.target,
-						selected: sel
+			}
+			andWhereOp(col, op, ...args) {
+				const value = args[0];
+				this.s.andOps.push({
+					col,
+					op,
+					value
+				});
+				return this;
+			}
+			orWhereOp(col, op, ...args) {
+				const value = args[0];
+				this.s.orOpGroups.push([{
+					col,
+					op,
+					value
+				}]);
+				return this;
+			}
+			andWhereOpGroup(predicates) {
+				const group = predicates.map((p) => ({
+					col: p[0],
+					op: p[1],
+					value: p[2]
+				}));
+				for (const g of group) this.s.andOps.push(g);
+				return this;
+			}
+			orWhereOpGroup(predicates) {
+				const group = predicates.map((p) => ({
+					col: p[0],
+					op: p[1],
+					value: p[2]
+				}));
+				this.s.orOpGroups.push(group);
+				return this;
+			}
+			orderBy(order) {
+				this.s.order = [];
+				const isValidDir = (d) => d === "asc" || d === "desc";
+				if (typeof order === "string") {
+					findColumn(table, String(order));
+					this.s.order.push({
+						col: order,
+						dir: "asc"
+					});
+				} else for (const item of order) {
+					const col = String(item[0]);
+					const dir = String(item[1]);
+					findColumn(table, col);
+					if (!isValidDir(dir)) throw new Error(`Invalid order direction: ${dir}. Allowed: asc | desc`);
+					this.s.order.push({
+						col: item[0],
+						dir
 					});
-					return this;
 				}
-				andWhere(where) {
-					for (const k in where) this.s.where[k] = where[k];
-					return this;
+				return this;
+			}
+			limit(n) {
+				if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid limit: ${n}. Limit must be a non-negative integer`);
+				this.s.limit = n;
+				return this;
+			}
+			offset(n) {
+				if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid offset: ${n}. Offset must be a non-negative integer`);
+				this.s.offset = n;
+				return this;
+			}
+			join(tableName, type = "inner") {
+				const target = findTable(schema, String(tableName));
+				const sources = [];
+				for (let i = this.s.joins.length - 1; i >= 0; i--) {
+					const src = this.s.joins[i].target;
+					if (!sources.some((s) => s.name === src.name)) sources.push(src);
 				}
-				/** @deprecated Use andWhere() instead */
-				where(where) {
-					return this.andWhere(where);
+				if (!sources.some((s) => s.name === table.name)) sources.push(table);
+				let pickedSource = null;
+				let pairs = null;
+				for (const src of sources) {
+					const p = findJoinOn(src, target);
+					if (p && p.length) {
+						pickedSource = src;
+						pairs = p;
+						break;
+					}
 				}
-				orWhere(where) {
-					this.s.orWhereGroups.push(where);
-					return this;
+				if (!pairs || !pickedSource) {
+					const candidates = sources.map((s) => s.name).join(", ");
+					throw new Error(`No foreign key relation found between any of [${candidates}] and ${target.name}`);
+				}
+				const jt = String(type);
+				if (jt !== "inner" && jt !== "left" && jt !== "right" && jt !== "full") throw new Error(`Invalid join type: ${jt}. Allowed: inner | left | right | full`);
+				this.s.joins.push({
+					type: jt,
+					source: pickedSource,
+					target,
+					on: pairs
+				});
+				return this;
+			}
+		}();
+	}
+	insert(values) {
+		const table = this.table;
+		const schema = this.schema;
+		const state = {
+			values,
+			returning: []
+		};
+		return new class {
+			returning(cols) {
+				state.returning = cols || [];
+				return this;
+			}
+			toSql() {
+				const colsArr = [];
+				const vals = [];
+				const params = {};
+				const type_hints = {};
+				let p = 0;
+				for (const key in state.values) {
+					const value = state.values[key];
+					const col = findColumn(table, key);
+					p += 1;
+					const paramName = `${table.name}_${key}_${p}`;
+					colsArr.push(`"${key}"`);
+					vals.push(`:${paramName}`);
+					params[paramName] = value;
+					addTypeHintForParam(type_hints, paramName, col, value);
 				}
-				wherePk(pk) {
+				const parts = [];
+				parts.push(`insert into "${schema.name}"."${table.name}" (${colsArr.join(", ")}) values (${vals.join(", ")})`);
+				if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+				const req = {
+					q: parts.join(" "),
+					params: Object.keys(params).length > 0 ? params : void 0,
+					type_hints: Object.keys(type_hints).length ? type_hints : void 0
+				};
+				return state.returning.length ? req : req;
+			}
+		}();
+	}
+	update(values) {
+		const table = this.table;
+		const schema = this.schema;
+		const state = {
+			values,
+			where: {},
+			returning: []
+		};
+		return new class {
+			constructor() {
+				this.where = (w) => {
+					for (const k in w) state.where[k] = w[k];
+					return this;
+				};
+				this.wherePk = (pk) => {
 					const pkCols = getPrimaryKeyColumns(table);
 					if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
 					if (pkCols.length === 1) {
@@ -1224,8 +1278,7 @@
 						if (Array.isArray(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}, not an array`);
 						if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}`);
 						validateScalarForColumn(colDef, pk, `primary key ${table.name}.${colName}`);
-						this.s.where[colName] = pk;
-						return this;
+						state.where[colName] = pk;
 					} else {
 						if (!isPlainObject(pk) || pk === null) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
 						const obj = pk;
@@ -1236,336 +1289,146 @@
 							if (v === null || v === void 0) throw new Error(`wherePk on ${table.name} requires non-null values for all primary key columns (${pkCols.join(", ")})`);
 							if (Array.isArray(v)) throw new Error(`wherePk on ${table.name} expects scalar values for primary key column ${colName}, not an array`);
 							validateScalarForColumn(findColumn(table, colName), v, `primary key ${table.name}.${colName}`);
-							this.s.where[colName] = v;
+							state.where[colName] = v;
 						}
-						return this;
 					}
-				}
-				andWhereOp(col, op, ...args) {
-					const value = args[0];
-					this.s.andOps.push({
-						col,
-						op,
-						value
-					});
-					return this;
-				}
-				orWhereOp(col, op, ...args) {
-					const value = args[0];
-					this.s.orOpGroups.push([{
-						col,
-						op,
-						value
-					}]);
-					return this;
-				}
-				andWhereOpGroup(predicates) {
-					const group = predicates.map((p) => ({
-						col: p[0],
-						op: p[1],
-						value: p[2]
-					}));
-					for (const g of group) this.s.andOps.push(g);
-					return this;
-				}
-				orWhereOpGroup(predicates) {
-					const group = predicates.map((p) => ({
-						col: p[0],
-						op: p[1],
-						value: p[2]
-					}));
-					this.s.orOpGroups.push(group);
 					return this;
+				};
+			}
+			returning(cols) {
+				state.returning = cols || [];
+				return this;
+			}
+			toSql() {
+				const params = {};
+				const type_hints = {};
+				let p = 0;
+				const setParts = [];
+				for (const key in state.values) {
+					const value = state.values[key];
+					const col = findColumn(table, key);
+					p += 1;
+					const paramName = `${table.name}_${key}_${p}`;
+					setParts.push(`"${key}" = :${paramName}`);
+					params[paramName] = value;
+					addTypeHintForParam(type_hints, paramName, col, value);
 				}
-				orderBy(order) {
-					this.s.order = [];
-					const isValidDir = (d) => d === "asc" || d === "desc";
-					if (typeof order === "string") {
-						findColumn(table, String(order));
-						this.s.order.push({
-							col: order,
-							dir: "asc"
-						});
-					} else for (const item of order) {
-						const col = String(item[0]);
-						const dir = String(item[1]);
-						findColumn(table, col);
-						if (!isValidDir(dir)) throw new Error(`Invalid order direction: ${dir}. Allowed: asc | desc`);
-						this.s.order.push({
-							col: item[0],
-							dir
-						});
+				const whereClauses = [];
+				for (const key in state.where) {
+					const value = state.where[key];
+					const col = findColumn(table, key);
+					p += 1;
+					const paramName = `${table.name}_${key}_${p}`;
+					if (value === null) {
+						if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+						whereClauses.push(`"${key}" is null`);
+					} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
+						validateInArrayValues(col, key, value, "in");
+						whereClauses.push(`"${key}" = ANY(:${paramName})`);
+						params[paramName] = value;
+						addTypeHintForParam(type_hints, paramName, col, value);
+					} else {
+						validateScalarForColumn(col, value, `column ${key}`);
+						whereClauses.push(`"${key}" = :${paramName}`);
+						params[paramName] = value;
+						addTypeHintForParam(type_hints, paramName, col, value);
 					}
-					return this;
 				}
-				limit(n) {
-					if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid limit: ${n}. Limit must be a non-negative integer`);
-					this.s.limit = n;
-					return this;
-				}
-				offset(n) {
-					if (typeof n !== "number" || !Number.isFinite(n) || !Number.isInteger(n) || n < 0) throw new Error(`Invalid offset: ${n}. Offset must be a non-negative integer`);
-					this.s.offset = n;
+				const parts = [];
+				parts.push(`update "${schema.name}"."${table.name}" set ${setParts.join(", ")}`);
+				if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
+				if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+				const req = {
+					q: parts.join(" "),
+					params: Object.keys(params).length > 0 ? params : void 0,
+					type_hints: Object.keys(type_hints).length ? type_hints : void 0
+				};
+				return state.returning.length ? req : req;
+			}
+		}();
+	}
+	delete() {
+		const table = this.table;
+		const schema = this.schema;
+		const state = {
+			where: {},
+			returning: []
+		};
+		return new class {
+			constructor() {
+				this.where = (w) => {
+					for (const k in w) state.where[k] = w[k];
 					return this;
-				}
-				join(tableName, type = "inner") {
-					const target = findTable(schema, String(tableName));
-					const sources = [];
-					for (let i = this.s.joins.length - 1; i >= 0; i--) {
-						const src = this.s.joins[i].target;
-						if (!sources.some((s) => s.name === src.name)) sources.push(src);
-					}
-					if (!sources.some((s) => s.name === table.name)) sources.push(table);
-					let pickedSource = null;
-					let pairs = null;
-					for (const src of sources) {
-						const p = findJoinOn(src, target);
-						if (p && p.length) {
-							pickedSource = src;
-							pairs = p;
-							break;
+				};
+				this.wherePk = (pk) => {
+					const pkCols = getPrimaryKeyColumns(table);
+					if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
+					if (pkCols.length === 1) {
+						const col = pkCols[0];
+						if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${col}`);
+						state.where[col] = pk;
+					} else {
+						if (!isPlainObject(pk)) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
+						const obj = pk;
+						for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
+						for (const col of pkCols) {
+							if (!(col in obj)) throw new Error(`wherePk missing key '${col}'. Required keys: ${pkCols.join(", ")}`);
+							state.where[col] = obj[col];
 						}
 					}
-					if (!pairs || !pickedSource) {
-						const candidates = sources.map((s) => s.name).join(", ");
-						throw new Error(`No foreign key relation found between any of [${candidates}] and ${target.name}`);
-					}
-					const jt = String(type);
-					if (jt !== "inner" && jt !== "left" && jt !== "right" && jt !== "full") throw new Error(`Invalid join type: ${jt}. Allowed: inner | left | right | full`);
-					this.s.joins.push({
-						type: jt,
-						source: pickedSource,
-						target,
-						on: pairs
-					});
 					return this;
+				};
+			}
+			returning(cols) {
+				state.returning = cols || [];
+				return this;
+			}
+			toSql() {
+				const params = {};
+				const type_hints = {};
+				let p = 0;
+				const whereClauses = [];
+				for (const key in state.where) {
+					const value = state.where[key];
+					const col = findColumn(table, key);
+					p += 1;
+					const paramName = `${table.name}_${key}_${p}`;
+					if (value === null) {
+						if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
+						whereClauses.push(`"${key}" is null`);
+					} else if (Array.isArray(value)) {
+						validateInArrayValues(col, key, value, "in");
+						whereClauses.push(`"${key}" = ANY(:${paramName})`);
+						params[paramName] = value;
+						addTypeHintForParam(type_hints, paramName, col, value);
+					} else {
+						validateScalarForColumn(col, value, `column ${key}`);
+						whereClauses.push(`"${key}" = :${paramName}`);
+						params[paramName] = value;
+						addTypeHintForParam(type_hints, paramName, col, value);
+					}
 				}
-			}();
-		}
-		insert(values) {
-			const table = this.table;
-			const schema = this.schema;
-			const state = {
-				values,
-				returning: []
-			};
-			return new class {
-				constructor() {
-					this.returning = (cols) => {
-						state.returning = cols || [];
-						return this;
-					};
-					this.toSql = () => {
-						const cols = [];
-						const vals = [];
-						const params = {};
-						const type_hints = {};
-						let p = 0;
-						for (const key in state.values) {
-							const value = state.values[key];
-							const col = findColumn(table, key);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							cols.push(`"${key}"`);
-							vals.push(`:${paramName}`);
-							params[paramName] = value;
-							addTypeHintForParam(type_hints, paramName, col, value);
-						}
-						const parts = [];
-						parts.push(`insert into "${schema.name}"."${table.name}" (${cols.join(", ")}) values (${vals.join(", ")})`);
-						if (state.returning.length) parts.push("returning " + state.returning.join(", "));
-						return {
-							q: parts.join(" "),
-							params: Object.keys(params).length > 0 ? params : void 0,
-							type_hints: Object.keys(type_hints).length ? type_hints : void 0
-						};
-					};
-				}
-			}();
-		}
-		update(values) {
-			const table = this.table;
-			const schema = this.schema;
-			const state = {
-				values,
-				where: {},
-				returning: []
-			};
-			return new class {
-				constructor() {
-					this.where = (w) => {
-						for (const k in w) state.where[k] = w[k];
-						return this;
-					};
-					this.wherePk = (pk) => {
-						const pkCols = getPrimaryKeyColumns(table);
-						if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
-						if (pkCols.length === 1) {
-							const colName = pkCols[0];
-							const colDef = findColumn(table, colName);
-							if (pk === null || pk === void 0) throw new Error(`wherePk on ${table.name} requires a non-null value for primary key column ${colName}`);
-							if (Array.isArray(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}, not an array`);
-							if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${colName}`);
-							validateScalarForColumn(colDef, pk, `primary key ${table.name}.${colName}`);
-							state.where[colName] = pk;
-						} else {
-							if (!isPlainObject(pk) || pk === null) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
-							const obj = pk;
-							for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
-							for (const colName of pkCols) {
-								if (!(colName in obj)) throw new Error(`wherePk missing key '${colName}'. Required keys: ${pkCols.join(", ")}`);
-								const v = obj[colName];
-								if (v === null || v === void 0) throw new Error(`wherePk on ${table.name} requires non-null values for all primary key columns (${pkCols.join(", ")})`);
-								if (Array.isArray(v)) throw new Error(`wherePk on ${table.name} expects scalar values for primary key column ${colName}, not an array`);
-								validateScalarForColumn(findColumn(table, colName), v, `primary key ${table.name}.${colName}`);
-								state.where[colName] = v;
-							}
-						}
-						return this;
-					};
-					this.returning = (cols) => {
-						state.returning = cols || [];
-						return this;
-					};
-					this.toSql = () => {
-						const params = {};
-						const type_hints = {};
-						let p = 0;
-						const setParts = [];
-						for (const key in state.values) {
-							const value = state.values[key];
-							const col = findColumn(table, key);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							setParts.push(`"${key}" = :${paramName}`);
-							params[paramName] = value;
-							addTypeHintForParam(type_hints, paramName, col, value);
-						}
-						const whereClauses = [];
-						for (const key in state.where) {
-							const value = state.where[key];
-							const col = findColumn(table, key);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							if (value === null) {
-								if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
-								whereClauses.push(`"${key}" is null`);
-							} else if (Array.isArray(value) && !isArrayShapedGeomScalarValue(col, value)) {
-								validateInArrayValues(col, key, value, "in");
-								whereClauses.push(`"${key}" = ANY(:${paramName})`);
-								params[paramName] = value;
-								addTypeHintForParam(type_hints, paramName, col, value);
-							} else {
-								validateScalarForColumn(col, value, `column ${key}`);
-								whereClauses.push(`"${key}" = :${paramName}`);
-								params[paramName] = value;
-								addTypeHintForParam(type_hints, paramName, col, value);
-							}
-						}
-						const parts = [];
-						parts.push(`update "${schema.name}"."${table.name}" set ${setParts.join(", ")}`);
-						if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
-						if (state.returning.length) parts.push("returning " + state.returning.join(", "));
-						return {
-							q: parts.join(" "),
-							params: Object.keys(params).length > 0 ? params : void 0,
-							type_hints: Object.keys(type_hints).length ? type_hints : void 0
-						};
-					};
-				}
-			}();
-		}
-		delete() {
-			const table = this.table;
-			const schema = this.schema;
-			const state = {
-				where: {},
-				returning: []
-			};
-			return new class {
-				constructor() {
-					this.where = (w) => {
-						for (const k in w) state.where[k] = w[k];
-						return this;
-					};
-					this.wherePk = (pk) => {
-						const pkCols = getPrimaryKeyColumns(table);
-						if (!pkCols || pkCols.length === 0) throw new Error(`Table ${table.name} does not have a primary key`);
-						if (pkCols.length === 1) {
-							const col = pkCols[0];
-							if (isPlainObject(pk)) throw new Error(`wherePk on ${table.name} expects a scalar for primary key column ${col}`);
-							state.where[col] = pk;
-						} else {
-							if (!isPlainObject(pk)) throw new Error(`wherePk on ${table.name} requires an object with keys: ${pkCols.join(", ")}`);
-							const obj = pk;
-							for (const k of Object.keys(obj)) if (!pkCols.includes(k)) throw new Error(`wherePk received unknown key '${k}'. Expected keys: ${pkCols.join(", ")}`);
-							for (const col of pkCols) {
-								if (!(col in obj)) throw new Error(`wherePk missing key '${col}'. Required keys: ${pkCols.join(", ")}`);
-								state.where[col] = obj[col];
-							}
-						}
-						return this;
-					};
-					this.returning = (cols) => {
-						state.returning = cols || [];
-						return this;
-					};
-					this.toSql = () => {
-						const params = {};
-						const type_hints = {};
-						let p = 0;
-						const whereClauses = [];
-						for (const key in state.where) {
-							const value = state.where[key];
-							const col = findColumn(table, key);
-							p += 1;
-							const paramName = `${table.name}_${key}_${p}`;
-							if (value === null) {
-								if (!col.is_nullable) throw new Error(`Column ${table.name}.${key} is not nullable; cannot compare to null`);
-								whereClauses.push(`"${key}" is null`);
-							} else if (Array.isArray(value)) {
-								validateInArrayValues(col, key, value, "in");
-								whereClauses.push(`"${key}" = ANY(:${paramName})`);
-								params[paramName] = value;
-								addTypeHintForParam(type_hints, paramName, col, value);
-							} else {
-								validateScalarForColumn(col, value, `column ${key}`);
-								whereClauses.push(`"${key}" = :${paramName}`);
-								params[paramName] = value;
-								addTypeHintForParam(type_hints, paramName, col, value);
-							}
-						}
-						const parts = [];
-						parts.push(`delete from "${schema.name}"."${table.name}"`);
-						if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
-						if (state.returning.length) parts.push("returning " + state.returning.join(", "));
-						return {
-							q: parts.join(" "),
-							params: Object.keys(params).length > 0 ? params : void 0,
-							type_hints: Object.keys(type_hints).length ? type_hints : void 0
-						};
-					};
-				}
-			}();
-		}
-	};
-	function createSqlBuilder(schema) {
-		return { table: (name) => new TableQueryImpl(schema, String(name)) };
+				const parts = [];
+				parts.push(`delete from "${schema.name}"."${table.name}"`);
+				if (whereClauses.length) parts.push("where " + whereClauses.join(" and "));
+				if (state.returning.length) parts.push("returning " + state.returning.join(", "));
+				const req = {
+					q: parts.join(" "),
+					params: Object.keys(params).length > 0 ? params : void 0,
+					type_hints: Object.keys(type_hints).length ? type_hints : void 0
+				};
+				return state.returning.length ? req : req;
+			}
+		}();
 	}
-
-//#endregion
-//#region src/index.ts
-/**
-	* @author     Martin Høgh <mh@mapcentia.com>
-	* @copyright  2013-2026 MapCentia ApS
-	* @license    https://opensource.org/license/mit  The MIT License
-	*
-	*/
+};
+function createSqlBuilder(schema) {
+	return { table: (name) => new TableQueryImpl(schema, String(name)) };
+}
 
 //#endregion
 exports.Claims = Claims;
 exports.CodeFlow = CodeFlow;
-exports.Gql = Gql;
 exports.Meta = Meta;
 exports.PasswordFlow = PasswordFlow;
 exports.Rpc = Rpc;