@adrdp/pg-rest 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,3549 @@
+//#region src/errors.ts
+/**
+* Thrown by the pure parts of the library (parsers, SQL builders). It is
+* converted into an {@link ApiError} at the request boundary.
+*/
+var PgRestError = class extends Error {
+	constructor(status, code, message, details = null, hint = null, headers = {}) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.details = details;
+		this.hint = hint;
+		this.headers = headers;
+		this.name = "PgRestError";
+	}
+	get body() {
+		return {
+			code: this.code,
+			message: this.message,
+			details: this.details,
+			hint: this.hint
+		};
+	}
+};
+/** An error that has already been mapped to an HTTP response. */
+var ApiError = class extends Error {
+	_tag = "ApiError";
+	status;
+	body;
+	headers;
+	constructor(fields) {
+		super(fields.body.message);
+		this.name = "ApiError";
+		this.status = fields.status;
+		this.body = fields.body;
+		this.headers = fields.headers;
+	}
+};
+/** Normalized error thrown by a {@link DbAdapter}. */
+var DbQueryError = class extends Error {
+	constructor(sqlState, message, detail, hint) {
+		super(message);
+		this.sqlState = sqlState;
+		this.detail = detail;
+		this.hint = hint;
+		this.name = "DbQueryError";
+	}
+};
+const SQLSTATE = /^[0-9A-Z]{5}$/;
+/**
+* Recognise a database error thrown by any driver and turn it into a {@link DbQueryError}.
+* Drivers put the SQLSTATE in different places: `code` (node-postgres, postgres.js, PGlite),
+* `errno` (Bun.sql) or `sqlState`. Anything else (connection errors, bugs) is returned unchanged.
+*/
+const normalizeDbError = (e) => {
+	if (e instanceof DbQueryError || !e || typeof e !== "object") return e;
+	const x = e;
+	for (const key of [
+		"sqlState",
+		"code",
+		"errno"
+	]) {
+		const v = x[key];
+		if (typeof v === "string" && SQLSTATE.test(v)) return new DbQueryError(v, String(x["message"] ?? ""), typeof x["detail"] === "string" ? x["detail"] : void 0, typeof x["hint"] === "string" ? x["hint"] : void 0);
+	}
+	return e;
+};
+/**
+* SQLSTATE → HTTP status, following the PostgREST 16 table
+* (https://docs.postgrest.org/en/v16/references/errors.html).
+*/
+const statusFromSqlState = (state, role, anon) => {
+	if (/^PT\d{3}$/.test(state)) return Number(state.slice(2));
+	switch (state) {
+		case "23503":
+		case "23505": return 409;
+		case "25006": return 405;
+		case "42883":
+		case "42P01": return 404;
+		case "42P17": return 500;
+		case "42501": return role === anon ? 401 : 403;
+		case "P0001": return 400;
+		case "53400": return 500;
+	}
+	switch (state.slice(0, 2)) {
+		case "08":
+		case "53": return 503;
+		case "0L":
+		case "0P":
+		case "28": return 403;
+		case "09":
+		case "25":
+		case "2D":
+		case "38":
+		case "39":
+		case "3B":
+		case "40":
+		case "54":
+		case "55":
+		case "57":
+		case "58":
+		case "F0":
+		case "HV":
+		case "P0":
+		case "XX": return 500;
+		default: return 400;
+	}
+};
+/**
+* Map a Postgres error to a PostgREST-style API error.
+*
+* Supports PostgREST's custom error conventions:
+* - `RAISE ... USING ERRCODE = 'PTxyz'` → HTTP status xyz
+* - `RAISE SQLSTATE 'PGRST'` with a JSON message/detail
+*/
+const dbErrorToApiError = (err, role, anonymousRole) => {
+	if (err.sqlState === "PGRST") try {
+		const msg = JSON.parse(err.message);
+		const det = err.detail ? JSON.parse(err.detail) : {};
+		return new ApiError({
+			status: det.status ?? 500,
+			headers: det.headers ?? {},
+			body: {
+				code: msg.code ?? "PGRST",
+				message: msg.message ?? "",
+				details: msg.details ?? null,
+				hint: msg.hint ?? null
+			}
+		});
+	} catch {
+		return new ApiError({
+			status: 500,
+			headers: {},
+			body: {
+				code: "PGRST121",
+				message: "Could not parse JSON in the RAISE error",
+				details: err.message,
+				hint: null
+			}
+		});
+	}
+	return new ApiError({
+		status: statusFromSqlState(err.sqlState, role, anonymousRole),
+		headers: {},
+		body: {
+			code: err.sqlState,
+			message: err.message,
+			details: err.detail ?? null,
+			hint: err.hint ?? null
+		}
+	});
+};
+
+//#endregion
+//#region src/parse/field.ts
+const parseError = (message, details) => new PgRestError(400, "PGRST100", message, details ?? null);
+/**
+* Scan `s` while tracking double-quote and parenthesis state, calling `visit`
+* with the index of every character that is at depth 0 and outside quotes.
+* Returning `true` from `visit` stops the scan.
+*/
+const scanTopLevel = (s, visit) => {
+	let depth = 0;
+	let quoted = false;
+	for (let i = 0; i < s.length; i++) {
+		const ch = s[i];
+		if (quoted) {
+			if (ch === "\\") i++;
+			else if (ch === "\"") quoted = false;
+			continue;
+		}
+		if (ch === "\"") {
+			quoted = true;
+			continue;
+		}
+		if (ch === "(") {
+			depth++;
+			continue;
+		}
+		if (ch === ")") {
+			depth--;
+			continue;
+		}
+		if (depth === 0 && visit(i, ch) === true) return;
+	}
+};
+/** Split on `sep` at depth 0, outside quotes. */
+const splitTopLevel = (s, sep) => {
+	const parts = [];
+	let start = 0;
+	scanTopLevel(s, (i, ch) => {
+		if (ch === sep) {
+			parts.push(s.slice(start, i));
+			start = i + 1;
+		}
+	});
+	parts.push(s.slice(start));
+	return parts;
+};
+const unquote = (s) => {
+	const t = s.trim();
+	if (t.length >= 2 && t.startsWith("\"") && t.endsWith("\"")) return t.slice(1, -1).replace(/\\(["\\])/g, "$1");
+	return t;
+};
+/** Parse `col`, `"odd col"`, `col->a->>b`, `col->0`. */
+const parseField = (input) => {
+	const s = input.trim();
+	if (!s) throw parseError("Empty column name");
+	const tokens = [];
+	const arrows = [];
+	let start = 0;
+	let quoted = false;
+	for (let i = 0; i < s.length; i++) {
+		const ch = s[i];
+		if (quoted) {
+			if (ch === "\\") i++;
+			else if (ch === "\"") quoted = false;
+			continue;
+		}
+		if (ch === "\"") quoted = true;
+		else if (ch === "-" && s[i + 1] === ">") {
+			const long = s[i + 2] === ">";
+			tokens.push(s.slice(start, i));
+			arrows.push(long ? "->>" : "->");
+			i += long ? 2 : 1;
+			start = i + 1;
+		}
+	}
+	tokens.push(s.slice(start));
+	const name = unquote(tokens[0]);
+	if (!name) throw parseError("Empty column name", `in "${input}"`);
+	const json = [];
+	for (let i = 1; i < tokens.length; i++) {
+		const raw = tokens[i].trim();
+		if (!raw) throw parseError("Invalid JSON path", `in "${input}"`);
+		const isIndex = /^-?\d+$/.test(raw);
+		json.push({
+			arrow: arrows[i - 1],
+			key: isIndex ? raw : unquote(raw),
+			isIndex
+		});
+	}
+	return {
+		name,
+		json
+	};
+};
+
+//#endregion
+//#region src/quote.ts
+/** Quote an SQL identifier: `a"b` → `"a""b"`. */
+const quoteIdent = (name) => {
+	if (name.includes("\0")) throw new PgRestError(400, "PGRST100", "Invalid identifier", "contains a NUL byte");
+	return `"${name.replace(/"/g, "\"\"")}"`;
+};
+const quoteQualified = (schema, name) => `${quoteIdent(schema)}.${quoteIdent(name)}`;
+/**
+* Escape a string as an SQL literal of *unknown* type, so Postgres infers the
+* type from context (`int_col = '5'` works). Mirrors `pg.escapeLiteral`.
+*
+* We inline literals (like PostgREST does) instead of binding parameters
+* because some drivers (Bun.sql) re-encode string parameters as JSON when the
+* inferred type is json/jsonb.
+*/
+const literal = (value) => {
+	if (value.includes("\0")) throw new PgRestError(400, "PGRST100", "Invalid value", "contains a NUL byte");
+	let out = `'${value.replace(/'/g, "''")}'`;
+	if (out.includes("\\")) out = `E${out.replace(/\\/g, "\\\\")}`;
+	return out;
+};
+const ID = "[A-Za-z_][A-Za-z0-9_]*";
+const TYPE_RE = new RegExp(`^(?:(?:double precision|character varying|national character varying|national character|bit varying|timestamp(?:\\(\\d+\\))? with(?:out)? time zone|time(?:\\(\\d+\\))? with(?:out)? time zone)|${ID}(?:\\.${ID})?)(?:\\(\\s*\\d+(?:\\s*,\\s*\\d+)?\\s*\\))?(?:\\[\\])*$`, "i");
+/** Validate a user-supplied cast target (`::type`) and return it verbatim. */
+const safeType = (type) => {
+	const t = type.trim();
+	if (t.length > 100 || !TYPE_RE.test(t)) throw new PgRestError(400, "PGRST100", "Invalid type in cast", `"${type}" is not an allowed cast target`);
+	return t;
+};
+
+//#endregion
+//#region src/parse/select.ts
+const AGGREGATES = new Set([
+	"count",
+	"sum",
+	"avg",
+	"max",
+	"min"
+]);
+/** Output key of a field in the JSON result. */
+const outputName = (item) => {
+	if (item.alias) return item.alias;
+	if (item.kind === "aggregate") return item.fn;
+	const last = item.field.json[item.field.json.length - 1];
+	return last ? last.key : item.field.name;
+};
+const parseItem = (raw) => {
+	let s = raw.trim();
+	if (!s) throw parseError("Empty item in select", `in "${raw}"`);
+	if (s === "*") return { kind: "star" };
+	let spread = false;
+	if (s.startsWith("...")) {
+		spread = true;
+		s = s.slice(3);
+	}
+	let cast;
+	let castAt = -1;
+	scanTopLevel(s, (i, ch) => {
+		if (ch === ":" && s[i + 1] === ":") castAt = i;
+	});
+	if (castAt >= 0) {
+		cast = safeType(s.slice(castAt + 2));
+		s = s.slice(0, castAt);
+	}
+	let alias;
+	let aliasAt = -1;
+	scanTopLevel(s, (i, ch) => {
+		if (ch === ":") {
+			aliasAt = i;
+			return true;
+		}
+		return false;
+	});
+	if (aliasAt >= 0) {
+		alias = unquote(s.slice(0, aliasAt));
+		s = s.slice(aliasAt + 1).trim();
+		if (!alias) throw parseError("Empty alias in select", `in "${raw}"`);
+	}
+	const parenAt = firstParen(s);
+	if (parenAt >= 0) {
+		if (!s.endsWith(")")) throw parseError("Unbalanced parentheses in select", `in "${raw}"`);
+		const head = s.slice(0, parenAt).trim();
+		const inner = s.slice(parenAt + 1, -1);
+		if (inner.trim() === "") {
+			const dot = head.lastIndexOf(".");
+			const fn = (dot >= 0 ? head.slice(dot + 1) : head).trim().toLowerCase();
+			const colPart = dot >= 0 ? head.slice(0, dot) : "";
+			if (AGGREGATES.has(fn) && (colPart || fn === "count")) {
+				if (spread) throw parseError("Cannot spread an aggregate", `in "${raw}"`);
+				return {
+					kind: "aggregate",
+					fn,
+					...colPart ? { field: parseField(colPart) } : {},
+					...alias ? { alias } : {},
+					...cast ? { cast } : {}
+				};
+			}
+		}
+		if (cast) throw parseError("Cannot cast an embedded resource", `in "${raw}"`);
+		const [targetRaw, ...mods] = splitTopLevel(head, "!");
+		const target = unquote(targetRaw ?? "");
+		if (!target) throw parseError("Empty embedded resource name", `in "${raw}"`);
+		let join$1 = "left";
+		let hint;
+		for (const m of mods) {
+			const mod = unquote(m);
+			if (mod === "inner") join$1 = "inner";
+			else if (mod === "left") join$1 = "left";
+			else if (hint === void 0) hint = mod;
+			else throw parseError("Only one hint is allowed per embedded resource", `in "${raw}"`);
+		}
+		return {
+			kind: "embed",
+			target,
+			...alias ? { alias } : {},
+			...hint ? { hint } : {},
+			join: join$1,
+			spread,
+			items: inner.trim() === "" ? [] : parseSelect(inner)
+		};
+	}
+	if (spread) throw parseError("Only embedded resources can be spread", `in "${raw}"`);
+	return {
+		kind: "field",
+		field: parseField(s),
+		...alias ? { alias } : {},
+		...cast ? { cast } : {}
+	};
+};
+const firstParen = (s) => {
+	let quoted = false;
+	for (let i = 0; i < s.length; i++) {
+		const ch = s[i];
+		if (quoted) {
+			if (ch === "\\") i++;
+			else if (ch === "\"") quoted = false;
+		} else if (ch === "\"") quoted = true;
+		else if (ch === "(") return i;
+	}
+	return -1;
+};
+/** Parse the value of the `select` query parameter. */
+const parseSelect = (input) => {
+	if (input.trim() === "") return [{ kind: "star" }];
+	return splitTopLevel(input, ",").map(parseItem);
+};
+
+//#endregion
+//#region src/parse/parsec.ts
+/**
+* A tiny port of Haskell's Parsec (the semantics of consumed/empty results, `try`, `<|>`, labels and error
+* merging), just enough to run PostgREST's parsers and produce the same error messages.
+*/
+/** Message kinds, in Parsec's sort order. */
+const SYS_UNEXPECT = 0;
+const UNEXPECT = 1;
+const EXPECT = 2;
+const MESSAGE = 3;
+const unknown = (pos) => ({
+	pos,
+	msgs: []
+});
+const mergeError = (e1, e2) => {
+	if (e2.msgs.length === 0 && e1.msgs.length > 0) return e1;
+	if (e1.msgs.length === 0 && e2.msgs.length > 0) return e2;
+	if (e1.pos === e2.pos) return {
+		pos: e1.pos,
+		msgs: [...e1.msgs, ...e2.msgs]
+	};
+	return e1.pos > e2.pos ? e1 : e2;
+};
+const setExpect = (e, label$1) => ({
+	pos: e.pos,
+	msgs: [...e.msgs.filter((m) => m.k !== EXPECT), ...label$1 ? [{
+		k: EXPECT,
+		s: label$1
+	}] : []]
+});
+const showChar = (c) => `'${c}'`;
+/** Haskell `show` of a one-character string. */
+const showStr1 = (c) => {
+	if (c === "\"") return "\"\\\"\"";
+	if (c === "\\") return "\"\\\\\"";
+	if (c === "\n") return "\"\\n\"";
+	if (c === "	") return "\"\\t\"";
+	const code = c.codePointAt(0);
+	return code > 126 || code < 32 ? `"\\${code}"` : `"${c}"`;
+};
+const showStr = (s) => s.length === 1 ? showStr1(s) : `"${s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+const pure = (v) => (_s, i) => ({
+	ok: true,
+	consumed: false,
+	v,
+	i,
+	err: unknown(i)
+});
+const zero = (_s, i) => ({
+	ok: false,
+	consumed: false,
+	err: unknown(i)
+});
+const unexpected = (msg) => (_s, i) => ({
+	ok: false,
+	consumed: false,
+	err: {
+		pos: i,
+		msgs: [{
+			k: UNEXPECT,
+			s: msg
+		}]
+	}
+});
+const codePointAt = (s, i) => {
+	if (i >= s.length) return void 0;
+	const cp = s.codePointAt(i);
+	return String.fromCodePoint(cp);
+};
+/** Consume one character satisfying `f`. */
+const satisfy = (f) => (s, i) => {
+	const c = codePointAt(s, i);
+	if (c === void 0) return {
+		ok: false,
+		consumed: false,
+		err: {
+			pos: i,
+			msgs: [{
+				k: SYS_UNEXPECT,
+				s: ""
+			}]
+		}
+	};
+	if (!f(c)) return {
+		ok: false,
+		consumed: false,
+		err: {
+			pos: i,
+			msgs: [{
+				k: SYS_UNEXPECT,
+				s: showStr1(c)
+			}]
+		}
+	};
+	const j = i + c.length;
+	return {
+		ok: true,
+		consumed: true,
+		v: c,
+		i: j,
+		err: unknown(j)
+	};
+};
+const label = (p, name) => (s, i) => {
+	const r = p(s, i);
+	if (r.consumed) return r;
+	if (r.ok) return {
+		...r,
+		err: r.err.msgs.length === 0 ? r.err : setExpect(r.err, name)
+	};
+	return {
+		...r,
+		err: setExpect(r.err, name)
+	};
+};
+const char = (c) => label(satisfy((x) => x === c), showStr1(c));
+const oneOf = (cs) => satisfy((x) => cs.includes(x));
+const noneOf = (cs) => satisfy((x) => !cs.includes(x));
+const anyChar = satisfy(() => true);
+const letter = label(satisfy((c) => /\p{L}/u.test(c)), "letter");
+const digit = label(satisfy((c) => c >= "0" && c <= "9"), "digit");
+/** Parsec's `string`: fails after consuming when only a prefix matches (wrap in `tryP` to backtrack). */
+const string = (w) => (s, i) => {
+	const expect = {
+		k: EXPECT,
+		s: showStr(w)
+	};
+	for (let k = 0; k < w.length; k++) {
+		const c = codePointAt(s, i + k);
+		if (c === void 0) return {
+			ok: false,
+			consumed: k > 0,
+			err: {
+				pos: i,
+				msgs: [{
+					k: SYS_UNEXPECT,
+					s: ""
+				}, expect]
+			}
+		};
+		if (c !== w[k]) {
+			const err = {
+				pos: i,
+				msgs: [{
+					k: SYS_UNEXPECT,
+					s: showStr1(c)
+				}, expect]
+			};
+			return {
+				ok: false,
+				consumed: k > 0,
+				err
+			};
+		}
+	}
+	const j = i + w.length;
+	return {
+		ok: true,
+		consumed: w.length > 0,
+		v: w,
+		i: j,
+		err: unknown(j)
+	};
+};
+const tryP = (p) => (s, i) => {
+	const r = p(s, i);
+	return !r.ok && r.consumed ? {
+		ok: false,
+		consumed: false,
+		err: r.err
+	} : r;
+};
+const bind = (p, f) => (s, i) => {
+	const r = p(s, i);
+	if (!r.ok) return r;
+	const q = f(r.v)(s, r.i);
+	if (r.consumed) {
+		if (q.consumed) return q;
+		return q.ok ? {
+			...q,
+			consumed: true,
+			err: mergeError(r.err, q.err)
+		} : {
+			ok: false,
+			consumed: true,
+			err: mergeError(r.err, q.err)
+		};
+	}
+	if (q.consumed) return q;
+	return q.ok ? {
+		...q,
+		err: mergeError(r.err, q.err)
+	} : {
+		ok: false,
+		consumed: false,
+		err: mergeError(r.err, q.err)
+	};
+};
+const map = (p, f) => bind(p, (a) => pure(f(a)));
+/** `p <* q` */
+const before = (p, q) => bind(p, (a) => map(q, () => a));
+/** `p *> q` */
+const after = (p, q) => bind(p, () => q);
+const alt = (...ps) => (s, i) => {
+	let acc;
+	for (const p of ps) {
+		const r = p(s, i);
+		if (r.consumed) return r;
+		if (r.ok) return acc ? {
+			...r,
+			err: mergeError(acc, r.err)
+		} : r;
+		acc = acc ? mergeError(acc, r.err) : r.err;
+	}
+	return {
+		ok: false,
+		consumed: false,
+		err: acc ?? unknown(i)
+	};
+};
+const many = (p) => (s, i) => {
+	const out = [];
+	let consumed = false;
+	let pos = i;
+	for (;;) {
+		const r = p(s, pos);
+		if (!r.ok) {
+			if (r.consumed) return r;
+			return {
+				ok: true,
+				consumed,
+				v: out,
+				i: pos,
+				err: r.err
+			};
+		}
+		if (!r.consumed) throw new Error("combinator 'many' is applied to a parser that accepts an empty string");
+		out.push(r.v);
+		consumed = true;
+		pos = r.i;
+	}
+};
+const many1 = (p) => bind(p, (x) => map(many(p), (xs) => [x, ...xs]));
+const sepBy1 = (p, sep) => bind(p, (x) => map(many(after(sep, p)), (xs) => [x, ...xs]));
+const sepBy = (p, sep) => alt(sepBy1(p, sep), pure([]));
+const option = (d, p) => alt(p, pure(d));
+const optionMaybe = (p) => option(void 0, p);
+const between = (open, close, p) => after(open, before(p, close));
+const lookAhead = (p) => (s, i) => {
+	const r = p(s, i);
+	if (!r.ok) return r;
+	return {
+		ok: true,
+		consumed: false,
+		v: r.v,
+		i,
+		err: unknown(i)
+	};
+};
+const notFollowedBy = (p) => tryP(alt(bind(tryP(p), (c) => unexpected(typeof c === "string" && c.length === 1 ? showChar(c) : showStr(String(c)))), pure(void 0)));
+/** `eof` does not move the error position past the offending character (Parsec's `anyToken` keeps the position). */
+const eof = label((s, i) => {
+	const c = codePointAt(s, i);
+	if (c === void 0) return {
+		ok: true,
+		consumed: false,
+		v: void 0,
+		i,
+		err: unknown(i)
+	};
+	return {
+		ok: false,
+		consumed: false,
+		err: {
+			pos: i,
+			msgs: [{
+				k: UNEXPECT,
+				s: showChar(c)
+			}]
+		}
+	};
+}, "end of input");
+const guard = (ok) => ok ? pure(void 0) : zero;
+const columnAt = (s, offset) => {
+	let col = 1;
+	for (let k = 0; k < offset; k++) col = s[k] === "	" ? col + 8 - (col - 1) % 8 : col + 1;
+	return col;
+};
+const clean = (xs) => [...new Set(xs.filter((x) => x !== ""))];
+const commasOr = (xs) => xs.length === 0 ? "" : xs.length === 1 ? xs[0] : `${xs.slice(0, -1).join(", ")} or ${xs[xs.length - 1]}`;
+/** Parsec's `showErrorMessages "or" "unknown parse error" "expecting" "unexpected" "end of input"`. */
+const showMessages = (msgs) => {
+	if (msgs.length === 0) return "unknown parse error";
+	const sorted = [...msgs].sort((a, b) => a.k - b.k);
+	const sys = sorted.filter((m) => m.k === SYS_UNEXPECT);
+	const unex = sorted.filter((m) => m.k === UNEXPECT);
+	const expect = sorted.filter((m) => m.k === EXPECT);
+	const other = sorted.filter((m) => m.k === MESSAGE);
+	const showMany = (pre, ms) => {
+		const c = commasOr(clean(ms.map((m) => m.s)));
+		return c === "" ? "" : pre ? `${pre} ${c}` : c;
+	};
+	return clean([
+		unex.length > 0 || sys.length === 0 ? "" : sys[0].s === "" ? "unexpected end of input" : `unexpected ${sys[0].s}`,
+		showMany("unexpected", unex),
+		showMany("expecting", expect),
+		showMany("", other)
+	]).join(" ");
+};
+/** Run `p` at the start of `input` (no `eof` is implied, as in Parsec's `parse`). */
+const run$1 = (p, input) => {
+	const r = p(input, 0);
+	if (r.ok) return {
+		ok: true,
+		value: r.v,
+		end: r.i
+	};
+	return {
+		ok: false,
+		failure: {
+			column: columnAt(input, r.err.pos),
+			details: showMessages(r.err.msgs).trim()
+		}
+	};
+};
+
+//#endregion
+//#region src/parse/grammar.ts
+/**
+* PostgREST v16's query-string parsers (`PostgREST.ApiRequest.QueryParams`), ported on top of `parsec.ts`
+* so that syntax errors read exactly like PostgREST's. They only validate: the structures the rest of the
+* library works with come from the hand-written parsers in this directory.
+*/
+const ws = many(oneOf(" 	"));
+const lexeme = (p) => before(after(ws, p), ws);
+const lazy = (f) => (s, i) => f()(s, i);
+const join = (xs) => xs.join("");
+const identifier = map(many1(alt(letter, digit, oneOf("_ $"))), (cs) => join(cs).trim());
+const dash = tryP(after(char("-"), notFollowedBy(char(">"))));
+const sepByDash = (p) => map(sepBy1(p, dash), (xs) => xs.join("-"));
+const slashedOrPlain = alt(noneOf("\\\""), after(char("\\"), anyChar));
+const quotedValue = map(between(char("\""), char("\""), many(slashedOrPlain)), join);
+const fieldName = label(alt(quotedValue, sepByDash(identifier)), "field name (* or [a..z0..9_$])");
+const jsonKeyName = label(alt(quotedValue, sepByDash(map(many1(noneOf("(-:.,>)")), (cs) => join(cs).trim()))), "any non reserved character different from: .,>()");
+const delimiter = label(char("."), "delimiter (.)");
+const jsonEnd = alt(tryP(lookAhead(string("->"))), tryP(lookAhead(string("::"))), tryP(lookAhead(string("."))), tryP(lookAhead(string(","))), tryP(eof));
+const jsonIdx = before(bind(option("+", char("-")), () => many1(digit)), jsonEnd);
+const jsonPath = many(after(alt(tryP(string("->>")), tryP(string("->"))), alt(tryP(jsonIdx), tryP(jsonKeyName))));
+const field = lexeme(bind(fieldName, () => option([], jsonPath)));
+const aliasPrefix = optionMaybe(tryP(before(fieldName, after(char(":"), notFollowedBy(char(":"))))));
+const embedParam = after(char("!"), alt(tryP(string("left")), tryP(string("inner")), tryP(fieldName)));
+const embedParams = after(optionMaybe(embedParam), optionMaybe(embedParam));
+const selectEnd = alt(tryP(lookAhead(string(")"))), tryP(lookAhead(string(","))), tryP(eof));
+const aggregation = alt(string("sum"), string("avg"), string("count"), tryP(string("max")), tryP(string("min")), zero);
+const relationSelect = lexeme(bind(aliasPrefix, () => bind(fieldName, (name) => after(guard(name !== "count"), after(embedParams, tryP(lookAhead(string("("))))))));
+const spreadRelationSelect = lexeme(after(string("..."), after(fieldName, after(embedParams, tryP(lookAhead(string("(")))))));
+const fieldSelect = lexeme(alt(tryP(after(string("*"), selectEnd)), tryP(after(aliasPrefix, after(string("count()"), after(optionMaybe(after(string("::"), identifier)), selectEnd)))), after(aliasPrefix, after(field, after(optionMaybe(after(string("::"), identifier)), after(optionMaybe(tryP(before(after(char("."), aggregation), string("()")))), after(optionMaybe(after(string("::"), identifier)), selectEnd)))))));
+const forest = sepBy(alt(bind(tryP(spreadRelationSelect), () => between(char("("), char(")"), lazy(() => forest))), bind(tryP(relationSelect), () => between(char("("), char(")"), lazy(() => forest))), fieldSelect), lexeme(char(",")));
+const ciChar = (c) => alt(char(c), char(c.toUpperCase()));
+const ciString = (w) => map(seq([...w].map(ciChar)), join);
+const seq = (ps) => ps.reduce((acc, p) => bind(acc, (xs) => map(p, (x) => [...xs, x])), pure([]));
+const listElement = alt(tryP(before(quotedValue, notFollowedBy(noneOf(",)")))), map(many(noneOf(",)")), join));
+const listVal = before(after(lexeme(char("(")), sepBy1(listElement, char(","))), lexeme(char(")")));
+const isVal = label(alt(tryP(ciString("null")), tryP(ciString("not_null")), tryP(ciString("true")), tryP(ciString("false")), tryP(ciString("unknown"))), "isVal: (null, not_null, true, false, unknown)");
+const simpleOperator = label(alt(...[
+	"neq",
+	"cs",
+	"cd",
+	"ov",
+	"sl",
+	"sr",
+	"nxr",
+	"nxl",
+	"adj"
+].map((o) => tryP(string(o)))), "unknown single value operator");
+const quantOperator = label(alt(...[
+	"eq",
+	"gte",
+	"gt",
+	"lte",
+	"lt",
+	"like",
+	"ilike",
+	"match",
+	"imatch"
+].map((o) => tryP(string(o)))), "unknown single value operator");
+const opExpr = (singleVal$1) => {
+	const pIn = after(tryP(after(string("in"), delimiter)), listVal);
+	const pIs = after(tryP(after(string("is"), delimiter)), isVal);
+	const pIsDist = after(tryP(after(string("isdistinct"), delimiter)), singleVal$1);
+	const pSimple = bind(simpleOperator, () => after(delimiter, singleVal$1));
+	const pQuant = bind(quantOperator, () => after(optionMaybe(tryP(between(char("("), char(")"), alt(tryP(string("any")), string("all"))))), after(delimiter, singleVal$1)));
+	const operation = label(alt(pIn, pIs, pIsDist, tryP(bind(alt(...[
+		"fts",
+		"plfts",
+		"phfts",
+		"wfts"
+	].map((o) => tryP(string(o)))), () => after(optionMaybe(tryP(between(char("("), char(")"), identifier))), after(delimiter, singleVal$1)))), tryP(pSimple), tryP(pQuant)), "operator (eq, gt, ...)");
+	return after(alt(tryP(after(string("not"), delimiter)), pure("")), operation);
+};
+const singleVal = map(many(anyChar), join);
+const orderEnd = alt(tryP(lookAhead(char(","))), tryP(eof));
+const orderNulls = alt(tryP(after(delimiter, string("nullsfirst"))), tryP(after(delimiter, string("nullslast"))));
+const orderTail = after(optionMaybe(alt(tryP(after(delimiter, string("asc"))), tryP(after(delimiter, string("desc"))))), alt(before(optionMaybe(orderNulls), orderEnd), after(orderEnd, pure(void 0))));
+const orderTerm = after(field, orderTail);
+const order = sepBy1(lexeme(alt(tryP(after(fieldName, after(between(char("("), char(")"), field), orderTail))), orderTerm)), char(","));
+const pgArray = map(bind(string("{"), (a) => bind(many(noneOf("{}")), (b) => map(string("}"), (c) => a + join(b) + c))), (x) => x);
+const logicSingleVal = alt(tryP(before(quotedValue, notFollowedBy(noneOf(",)")))), tryP(pgArray), map(many(noneOf(",)")), join));
+const logicNot = label(alt(tryP(after(string("not"), after(delimiter, pure(true)))), pure(false)), "negation operator (not)");
+const logicOp = label(alt(tryP(string("and")), string("or")), "logic operator (and, or)");
+const logicTree = alt(tryP(after(field, after(delimiter, opExpr(logicSingleVal)))), bind(logicNot, () => bind(logicOp, () => after(lexeme(char("(")), before(sepBy1(lazy(() => logicTree), lexeme(char(","))), lexeme(char(")")))))));
+const fail = (what, input, f) => new PgRestError(400, "PGRST100", `"failed to parse ${what} (${input})" (line 1, column ${f.column})`, f.details);
+/** `select=`: returns where the parse stopped (PostgREST ignores anything after it), or the error. */
+const checkSelect = (input) => {
+	const r = run$1(forest, input);
+	return r.ok ? r.end : fail("select parameter", input, r.failure);
+};
+/** The right-hand side of a filter (`not.eq.1`); `undefined` when it parses. */
+const checkFilter = (input) => {
+	const r = run$1(opExpr(singleVal), input);
+	return r.ok ? void 0 : fail("filter", input, r.failure);
+};
+/** An `order=` value; `undefined` when it parses. */
+const checkOrder = (input) => {
+	const r = run$1(order, input);
+	return r.ok ? void 0 : fail("order", input, r.failure);
+};
+/** `and=`/`or=`: `op` is `and`, `or`, `not.and` or `not.or`; returns how much of `value` the tree uses. */
+const checkLogicTree = (op, value) => {
+	const r = run$1(logicTree, op + value);
+	return r.ok ? Math.max(0, r.end - op.length) : fail("logic tree", value, r.failure);
+};
+
+//#endregion
+//#region src/parse/syntax.ts
+/** Helpers for the lenient parts of PostgREST's filter syntax (the error wording lives in `grammar.ts`). */
+const IS_VALUES_ORDER = [
+	"null",
+	"not_null",
+	"true",
+	"false",
+	"unknown"
+];
+const at = (s, i) => i < s.length ? s[i] : void 0;
+/**
+* Where a parenthesised `in` list ends (offset after the closing `)`). PostgREST stops there and ignores what follows;
+* an unterminated list returns the input length (the grammar reports the error before this is used).
+*/
+const scanList = (s, from) => {
+	let i = from + 1;
+	for (;;) {
+		let end = i;
+		if (at(s, i) === "\"") {
+			let k = i + 1;
+			while (k < s.length && s[k] !== "\"") k += s[k] === "\\" ? 2 : 1;
+			if (k < s.length && (at(s, k + 1) === "," || at(s, k + 1) === ")")) end = k + 1;
+		}
+		if (end === i) while (end < s.length && s[end] !== "," && s[end] !== ")") end++;
+		const c = at(s, end);
+		if (c === ")") return end + 1;
+		if (c !== ",") return s.length;
+		i = end + 1;
+	}
+};
+
+//#endregion
+//#region src/parse/filter.ts
+const OPERATORS = new Set([
+	"eq",
+	"neq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"like",
+	"ilike",
+	"match",
+	"imatch",
+	"in",
+	"is",
+	"isdistinct",
+	"fts",
+	"plfts",
+	"phfts",
+	"wfts",
+	"cs",
+	"cd",
+	"ov",
+	"sl",
+	"sr",
+	"nxl",
+	"nxr",
+	"adj"
+]);
+const QUANTIFIABLE = new Set([
+	"eq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"like",
+	"ilike",
+	"match",
+	"imatch"
+]);
+const FTS = new Set([
+	"fts",
+	"plfts",
+	"phfts",
+	"wfts"
+]);
+const IS_VALUES = new Set([
+	"null",
+	"not_null",
+	"true",
+	"false",
+	"unknown"
+]);
+const emptyParams = () => ({
+	filters: [],
+	order: [],
+	presence: []
+});
+const parseList = (raw, where) => {
+	const t = raw.trim();
+	if (!t.startsWith("(") || !t.endsWith(")")) throw parseError(`failed to parse filter (${where})`, "expected a list in parentheses, like (a,b,c)");
+	const inner = t.slice(1, -1);
+	if (inner.trim() === "") return [];
+	return splitTopLevel(inner, ",").map((v) => unquote(v));
+};
+/**
+* Parse `[not.]op[(modifier)].value`, the right-hand side of a filter.
+* `unquoteValue` is true inside and()/or() trees where values may be quoted.
+*/
+const parseOperatorExpr = (field$1, expr, unquoteValue = false) => {
+	if (!unquoteValue) {
+		const bad = checkFilter(expr);
+		if (bad) throw bad;
+	}
+	let rest = expr;
+	let negate = false;
+	if (rest.startsWith("not.")) {
+		negate = true;
+		rest = rest.slice(4);
+	}
+	const dot = rest.indexOf(".");
+	if (dot < 0) throw parseError(`failed to parse filter (${expr})`);
+	const opToken = rest.slice(0, dot);
+	const rawValue = rest.slice(dot + 1);
+	const m = /^([a-z]+)(?:\(([^)]*)\))?$/.exec(opToken);
+	if (!m || !OPERATORS.has(m[1])) throw parseError(`failed to parse filter (${expr})`, `unknown operator "${opToken}"`);
+	const op = m[1];
+	const modifier = m[2];
+	let quantifier;
+	let lang;
+	if (modifier !== void 0) if (QUANTIFIABLE.has(op)) {
+		if (modifier !== "any" && modifier !== "all") throw parseError(`failed to parse filter (${expr})`, `"${modifier}" is not a valid quantifier, use any or all`);
+		quantifier = modifier;
+	} else if (FTS.has(op)) {
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(modifier)) throw parseError(`failed to parse filter (${expr})`, `"${modifier}" is not a valid text search configuration`);
+		lang = modifier;
+	} else throw parseError(`failed to parse filter (${expr})`, `operator ${op} does not take a modifier`);
+	let value = unquoteValue ? unquote(rawValue) : rawValue;
+	if (op === "in") {
+		const end = unquoteValue ? void 0 : scanList(rawValue, 0);
+		value = parseList(typeof end === "number" ? rawValue.slice(0, end) : rawValue, expr);
+	} else if (op === "is") {
+		const v = ((unquoteValue ? void 0 : IS_VALUES_ORDER.find((w) => rawValue.startsWith(w))) ?? String(value)).toLowerCase();
+		if (!IS_VALUES.has(v)) throw parseError(`failed to parse filter (${expr})`, "is only accepts null, not_null, true, false and unknown");
+		value = v;
+	}
+	return {
+		kind: "filter",
+		field: field$1,
+		negate,
+		op,
+		...quantifier ? { quantifier } : {},
+		...lang ? { lang } : {},
+		value
+	};
+};
+const parseLogicItem = (raw) => {
+	const item = raw.trim();
+	const m = /^(not\.)?(and|or)\(/.exec(item);
+	if (m) {
+		if (!item.endsWith(")")) throw parseError("Unbalanced parentheses in logic tree", `in "${item}"`);
+		const inner = item.slice(m[0].length - 1);
+		return parseLogic(m[2], Boolean(m[1]), inner);
+	}
+	const dot = item.indexOf(".");
+	if (dot < 0) throw parseError(`failed to parse logic tree (${item})`);
+	return parseOperatorExpr(parseField(item.slice(0, dot)), item.slice(dot + 1), true);
+};
+/** Parse `(a.eq.1,or(b.eq.2,c.eq.3))` into a {@link Logic} node. */
+const parseLogic = (op, negate, value) => {
+	const v = value.trim();
+	if (!v.startsWith("(") || !v.endsWith(")")) throw parseError(`failed to parse logic tree (${value})`, "expected a list in parentheses");
+	const inner = v.slice(1, -1);
+	if (inner.trim() === "") throw parseError(`failed to parse logic tree (${value})`, "empty tree");
+	return {
+		kind: "logic",
+		op,
+		negate,
+		children: splitTopLevel(inner, ",").map(parseLogicItem)
+	};
+};
+const parseOrder = (input) => {
+	const bad = checkOrder(input);
+	if (bad) throw bad;
+	return parseOrderTerms(input);
+};
+const parseOrderTerms = (input) => splitTopLevel(input, ",").map((raw) => {
+	const tokens = raw.trim().split(".");
+	let nulls;
+	let dir = "asc";
+	const last = () => tokens[tokens.length - 1]?.toLowerCase();
+	if (tokens.length > 1 && (last() === "nullsfirst" || last() === "nullslast")) {
+		nulls = last() === "nullsfirst" ? "first" : "last";
+		tokens.pop();
+	}
+	if (tokens.length > 1 && (last() === "asc" || last() === "desc")) {
+		dir = last();
+		tokens.pop();
+	}
+	const expr = tokens.join(".");
+	const related = /^([^()>-]+)\((.+)\)$/.exec(expr);
+	if (related && /[()]/.test(related[2])) throw parseError(`"failed to parse order (${input})"`, `unexpected '(' in "${expr}"`);
+	return {
+		...related ? {
+			relation: unquote(related[1]),
+			field: parseField(related[2])
+		} : { field: parseField(expr) },
+		dir,
+		...nulls ? { nulls } : {}
+	};
+});
+/** PostgREST ignores a `limit`/`offset` that is not an integer; a negative limit is refused later. */
+const parseCount = (name, v) => {
+	return (name === "limit" ? /^-?\d+$/.test(v) : /^\d+$/.test(v)) ? Number(v) : void 0;
+};
+const walkEmbeds = (items, prefix, known) => {
+	for (const it of items) {
+		if (it.kind !== "embed") continue;
+		const name = it.alias ?? it.target;
+		const canonical = [...prefix, name].join(".");
+		known.set(canonical, canonical);
+		if (it.alias) known.set([...prefix, it.target].join("."), canonical);
+		walkEmbeds(it.items, [...prefix, name], known);
+	}
+};
+const RESERVED_TERMINALS = new Set([
+	"limit",
+	"offset",
+	"order",
+	"and",
+	"or"
+]);
+/** Parse everything PostgREST reads from the query string, except function arguments. */
+const parseQuery = (params, opts = {}) => {
+	let select = [{ kind: "star" }];
+	let onConflict;
+	let columns;
+	for (const [k, v] of params) if (k === "select") {
+		const end = checkSelect(v);
+		if (end instanceof PgRestError) throw end;
+		const used = v.slice(0, end).trim();
+		select = used === "" ? [{ kind: "star" }] : parseSelect(used);
+	} else if (k === "on_conflict") onConflict = splitTopLevel(v, ",").map(unquote).filter(Boolean);
+	else if (k === "columns") columns = splitTopLevel(v, ",").map(unquote).filter(Boolean);
+	const known = /* @__PURE__ */ new Map();
+	walkEmbeds(select, [], known);
+	const root = emptyParams();
+	const embeds = /* @__PURE__ */ new Map();
+	const paramsFor = (path, key) => {
+		if (path.length === 0) return root;
+		const joined = path.join(".");
+		const canonical = known.get(joined);
+		if (!canonical) throw new PgRestError(400, "PGRST108", `'${joined}' is not an embedded resource in this request`, null, `Verify that '${joined}' is included in the 'select' query parameter.`);
+		let p = embeds.get(canonical);
+		if (!p) {
+			p = emptyParams();
+			embeds.set(canonical, p);
+		}
+		return p;
+	};
+	for (const [key, value] of params) {
+		if (key === "select" || key === "on_conflict" || key === "columns") continue;
+		if (opts.allowFilterKey && !opts.allowFilterKey(key)) continue;
+		const parts = key.split(".");
+		const last = parts[parts.length - 1];
+		if (RESERVED_TERMINALS.has(last)) {
+			let path = parts.slice(0, -1);
+			if (last === "and" || last === "or") {
+				const negate = path[path.length - 1] === "not";
+				if (negate) path = path.slice(0, -1);
+				const used = checkLogicTree(negate ? `not.${last}` : last, value);
+				if (used instanceof PgRestError) throw used;
+				paramsFor(path, key).filters.push(parseLogic(last, negate, value.slice(0, used)));
+			} else if (last === "order") paramsFor(path, key).order.push(...parseOrder(value));
+			else if (last === "limit") {
+				const n = parseCount("limit", value);
+				if (n !== void 0) paramsFor(path, key).limit = n;
+			} else {
+				const n = parseCount("offset", value);
+				if (n !== void 0) paramsFor(path, key).offset = n;
+			}
+			continue;
+		}
+		const embedPath = parts.join(".");
+		if (known.has(embedPath)) {
+			const m = /^(not\.)?is\.null$/.exec(value);
+			if (!m) throw new PgRestError(400, "PGRST120", "Embedded resource filter only accepts is.null or not.is.null", null, null);
+			paramsFor(parts.slice(0, -1), key).presence.push({
+				embed: known.get(embedPath).split(".").pop(),
+				present: Boolean(m[1])
+			});
+			continue;
+		}
+		paramsFor(parts.slice(0, -1), key).filters.push(parseOperatorExpr(parseField(last), value));
+	}
+	return {
+		select,
+		root,
+		embeds,
+		...onConflict ? { onConflict } : {},
+		...columns ? { columns } : {}
+	};
+};
+
+//#endregion
+//#region src/parse/request.ts
+const METHODS = new Set([
+	"GET",
+	"HEAD",
+	"POST",
+	"PATCH",
+	"PUT",
+	"DELETE",
+	"OPTIONS"
+]);
+const isSupportedMethod = (m) => METHODS.has(m.toUpperCase());
+const parseMethod = (m) => {
+	const up = m.toUpperCase();
+	if (!METHODS.has(up)) throw new PgRestError(405, "PGRST117", `Unsupported HTTP method: ${m}`);
+	return up;
+};
+/**
+* Route a request path. `basePath` is stripped first, so the library can be
+* mounted anywhere (`/api/rest`, ...).
+*/
+const parseTarget = (pathname, basePath = "") => {
+	let path = pathname;
+	if (basePath && basePath !== "/") {
+		const base = basePath.replace(/\/+$/, "");
+		if (path === base) path = "/";
+		else if (path.startsWith(`${base}/`)) path = path.slice(base.length);
+		else throw new PgRestError(404, "PGRST125", `Invalid path specified in request URL`);
+	}
+	const segs = path.split("/").filter(Boolean).map((s) => {
+		try {
+			return decodeURIComponent(s);
+		} catch {
+			throw new PgRestError(400, "PGRST100", "Invalid URL encoding in path");
+		}
+	});
+	if (segs.length === 0) return { type: "root" };
+	if (segs[0] === "rpc") {
+		if (segs.length !== 2) throw new PgRestError(404, "PGRST125", "Invalid path specified in request URL");
+		return {
+			type: "rpc",
+			name: segs[1]
+		};
+	}
+	if (segs.length !== 1) throw new PgRestError(404, "PGRST125", "Invalid path specified in request URL");
+	return {
+		type: "table",
+		name: segs[0]
+	};
+};
+const PREFERENCE_VALUES = {
+	return: [
+		"minimal",
+		"headers-only",
+		"representation"
+	],
+	count: [
+		"exact",
+		"planned",
+		"estimated"
+	],
+	resolution: ["merge-duplicates", "ignore-duplicates"],
+	missing: ["default", "null"],
+	handling: ["strict", "lenient"],
+	tx: ["commit", "rollback"]
+};
+/** Parse one or more `Prefer` header values (comma separated tokens). */
+const parsePrefer = (header) => {
+	const out = { invalid: [] };
+	const invalid = [];
+	if (!header) return out;
+	for (const raw of header.split(",")) {
+		const token = raw.trim();
+		if (!token) continue;
+		const eq = token.indexOf("=");
+		if (eq < 0) {
+			invalid.push(token);
+			continue;
+		}
+		const key = token.slice(0, eq).trim().toLowerCase();
+		const value = token.slice(eq + 1).trim();
+		if (key === "timezone") out.timezone = value;
+		else if (key === "max-affected") if (/^\d+$/.test(value)) out.maxAffected = Number(value);
+		else invalid.push(token);
+		else if (PREFERENCE_VALUES[key]?.includes(value)) out[key] = value;
+		else invalid.push(token);
+	}
+	out.invalid = invalid;
+	return out;
+};
+/** `Range: 5-14` (with `Range-Unit: items`, or none). */
+const parseRange = (range, unit) => {
+	if (!range) return void 0;
+	if (unit && unit.toLowerCase() !== "items") return void 0;
+	const m = /^(?:items=)?(\d+)-(\d*)$/.exec(range.trim());
+	if (!m) return void 0;
+	const start = Number(m[1]);
+	if (m[2] === "") return { offset: start };
+	const end = Number(m[2]);
+	if (end < start) throw new PgRestError(416, "PGRST103", "Requested range not satisfiable", `The lower boundary must be lower than or equal to the upper boundary in the Range header.`, null);
+	return {
+		offset: start,
+		limit: end - start + 1
+	};
+};
+const parseAcceptEntry = (entry) => {
+	const [type = "", ...params] = entry.split(";").map((s) => s.trim());
+	let q = 1;
+	let stripNulls = false;
+	let forType;
+	let options = [];
+	for (const p of params) {
+		const eq = p.indexOf("=");
+		const k = (eq < 0 ? p : p.slice(0, eq)).trim();
+		const v = (eq < 0 ? "" : p.slice(eq + 1)).trim().replace(/^"|"$/g, "");
+		if (k === "q") q = Number(v);
+		else if (k === "nulls" && v === "stripped") stripNulls = true;
+		else if (k === "for") forType = v;
+		else if (k === "options") options = v.split("|").filter((o) => PLAN_OPTIONS.has(o));
+	}
+	return {
+		type: type.toLowerCase(),
+		q: Number.isNaN(q) ? 1 : q,
+		stripNulls,
+		forType,
+		options
+	};
+};
+const PLAN_OPTIONS = new Set([
+	"analyze",
+	"verbose",
+	"settings",
+	"buffers",
+	"wal"
+]);
+const describeEntry = (e) => {
+	if (!e.type.startsWith("application/vnd.pgrst.plan")) return e.type;
+	const fmt = e.type.endsWith("+json") ? "+json" : "+text";
+	const opts = e.options.length ? `; options=${e.options.join("|")}` : "";
+	return `application/vnd.pgrst.plan${fmt}; for="${e.forType ?? "application/json"}"${opts}`;
+};
+/** Pick an output format from the `Accept` header. */
+const parseAccept = (accept, isRoot, planEnabled = false, choices = []) => {
+	const entries = (accept ?? "*/*").split(",").map((e) => e.trim()).filter(Boolean).map(parseAcceptEntry).sort((a, b) => b.q - a.q);
+	if (entries.length === 0) entries.push({
+		type: "*/*",
+		q: 1,
+		stripNulls: false,
+		forType: void 0,
+		options: []
+	});
+	for (const { type, stripNulls, forType, options } of entries) {
+		if (type === "application/vnd.pgrst.plan" || type === "application/vnd.pgrst.plan+json" || type === "application/vnd.pgrst.plan+text") {
+			if (!planEnabled || isRoot) continue;
+			const inner = parseAccept(forType ?? "application/json", false, false);
+			return {
+				kind: "plan",
+				format: type.endsWith("+json") ? "json" : "text",
+				forType: forType ?? "application/json",
+				options,
+				inner
+			};
+		}
+		const custom = choices.find((c) => c.mediaType === type);
+		if (custom && !isRoot) return {
+			kind: "handler",
+			choice: custom
+		};
+		switch (type) {
+			case "*/*":
+			case "application/*":
+			case "application/json":
+			case "application/openapi+json":
+				if (isRoot) return { kind: "openapi" };
+				if (type !== "application/openapi+json") return {
+					kind: "json",
+					stripNulls
+				};
+				break;
+			case "application/vnd.pgrst.array+json": return {
+				kind: "json",
+				stripNulls
+			};
+			case "application/vnd.pgrst.object+json":
+			case "application/vnd.pgrst.object": return {
+				kind: "object",
+				stripNulls
+			};
+			case "text/csv": return { kind: "csv" };
+			case "application/geo+json":
+				if (!isRoot) return { kind: "geojson" };
+				break;
+		}
+	}
+	throw new PgRestError(406, "PGRST107", "None of these media types are available: " + entries.map(describeEntry).join(", "));
+};
+/** Decode the request body into a JSON string (array of objects, or an object). */
+const parseBody = async (request, method) => {
+	if (method !== "POST" && method !== "PATCH" && method !== "PUT") return void 0;
+	const ct = (request.headers.get("content-type") ?? "application/json").split(";")[0].trim().toLowerCase();
+	const text = await request.text();
+	if (ct === "application/json" || ct === "application/vnd.pgrst.array+json") {
+		if (text.trim() === "") return void 0;
+		try {
+			return {
+				kind: "json",
+				value: JSON.parse(text)
+			};
+		} catch {
+			throw new PgRestError(400, "PGRST102", "Empty or invalid json");
+		}
+	}
+	if (ct === "application/x-www-form-urlencoded") {
+		const obj = {};
+		for (const [k, v] of new URLSearchParams(text)) obj[k] = v;
+		return {
+			kind: "urlencoded",
+			value: obj
+		};
+	}
+	if (ct === "text/csv") return {
+		kind: "csv",
+		value: parseCsv(text)
+	};
+	throw new PgRestError(415, "PGRST107", `Content-Type not acceptable: ${ct}`);
+};
+/** Minimal RFC 4180 CSV → array of objects (first row is the header). */
+const parseCsv = (text) => {
+	const rows = [];
+	let row = [];
+	let field$1 = "";
+	let quoted = false;
+	let sawAny = false;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		sawAny = true;
+		if (quoted) if (ch === "\"") if (text[i + 1] === "\"") {
+			field$1 += "\"";
+			i++;
+		} else quoted = false;
+		else field$1 += ch;
+		else if (ch === "\"") quoted = true;
+		else if (ch === ",") {
+			row.push(field$1);
+			field$1 = "";
+		} else if (ch === "\n" || ch === "\r") {
+			if (ch === "\r" && text[i + 1] === "\n") i++;
+			row.push(field$1);
+			rows.push(row);
+			row = [];
+			field$1 = "";
+			sawAny = false;
+		} else field$1 += ch;
+	}
+	if (sawAny || field$1 !== "" || row.length > 0) {
+		row.push(field$1);
+		rows.push(row);
+	}
+	const [header, ...data] = rows;
+	if (!header) return [];
+	if (header.some((h) => h === "")) throw parseError("Invalid CSV", "the header row has an empty column name");
+	return data.filter((r) => !(r.length === 1 && r[0] === "")).map((r) => Object.fromEntries(header.map((h, i) => [h, r[i] === "" || r[i] === void 0 ? null : r[i]])));
+};
+
+//#endregion
+//#region src/schema.ts
+const relKey = (schema, name) => `${schema}.${name}`;
+const kindOf = (k) => k === "v" ? "view" : k === "m" ? "matview" : k === "f" ? "foreign" : k === "p" ? "partitioned" : "table";
+const schemaList = (schemas) => `ARRAY[${schemas.map(literal).join(",")}]::text[]`;
+const asJson = (inner) => `SELECT coalesce(json_agg(r), '[]'::json)::text AS j FROM (${inner}) r`;
+const run = async (db, sql) => {
+	const j = (await db.query(asJson(sql)))[0]?.["j"];
+	return JSON.parse(typeof j === "string" ? j : "[]");
+};
+/**
+* Foreign keys seen through views: a view that exposes the columns of a foreign key (directly, or
+* through other views) gets the same relationships as the table, towards tables and views alike.
+*/
+const viewForeignKeys = (fks, rows) => {
+	const viewCols = /* @__PURE__ */ new Map();
+	for (const r of rows) {
+		const key = relKey(r.vschema, r.vname);
+		const m = viewCols.get(key) ?? /* @__PURE__ */ new Map();
+		m.set(r.vcol, {
+			key: relKey(r.tschema, r.tname),
+			col: r.tcol
+		});
+		viewCols.set(key, m);
+	}
+	const base = (key, col, depth = 0) => {
+		const next = viewCols.get(key)?.get(col);
+		return next && depth < 16 ? base(next.key, next.col, depth + 1) : {
+			key,
+			col
+		};
+	};
+	/** Every view that exposes all of `cols` of table `tableKey`, with the view-side column names. */
+	const exposing = (tableKey, cols) => {
+		const out$1 = [];
+		for (const [vkey, m] of viewCols) {
+			const names = [];
+			for (const c of cols) {
+				let found;
+				for (const [vcol] of m) {
+					const b = base(vkey, vcol);
+					if (b.key === tableKey && b.col === c) {
+						found = vcol;
+						break;
+					}
+				}
+				if (found === void 0) break;
+				names.push(found);
+			}
+			if (names.length === cols.length) {
+				const [schema, ...rest] = vkey.split(".");
+				out$1.push({
+					schema,
+					name: rest.join("."),
+					cols: names
+				});
+			}
+		}
+		return out$1;
+	};
+	const out = [];
+	for (const fk of fks) {
+		const sources = [{
+			schema: fk.schema,
+			name: fk.table,
+			cols: [...fk.cols]
+		}, ...exposing(relKey(fk.schema, fk.table), fk.cols)];
+		const targets = [{
+			schema: fk.fschema,
+			name: fk.ftable,
+			cols: [...fk.fcols]
+		}, ...exposing(relKey(fk.fschema, fk.ftable), fk.fcols)];
+		for (const [i, s] of sources.entries()) for (const [j, t] of targets.entries()) {
+			if (i === 0 && j === 0) continue;
+			out.push({
+				name: fk.name,
+				schema: s.schema,
+				table: s.name,
+				cols: s.cols,
+				fschema: t.schema,
+				ftable: t.name,
+				fcols: t.cols
+			});
+		}
+	}
+	return out;
+};
+/** Read the catalog and build a fresh {@link SchemaCache}. */
+const introspect = async (db, schemas) => {
+	const S = schemaList(schemas);
+	const relRows = await run(db, `SELECT n.nspname AS schema, c.relname AS name, c.relkind::text AS kind,
+            obj_description(c.oid, 'pg_class') AS comment,
+            pg_relation_is_updatable(c.oid, true) AS bits
+       FROM pg_class c
+       JOIN pg_namespace n ON n.oid = c.relnamespace
+      WHERE n.nspname = ANY(${S})
+        AND c.relkind IN ('r','v','m','f','p')
+        AND NOT c.relispartition
+      ORDER BY 1, 2`);
+	const colRows = await run(db, `SELECT n.nspname AS schema, c.relname AS "table", a.attname AS name,
+            format_type(a.atttypid, a.atttypmod) AS type,
+            NOT a.attnotnull AS nullable,
+            (a.atthasdef OR a.attidentity <> '') AS has_default,
+            pg_get_expr(d.adbin, d.adrelid) AS default_expr,
+            (a.attgenerated <> '') AS generated,
+            col_description(c.oid, a.attnum) AS comment,
+            a.attnum AS pos
+       FROM pg_attribute a
+       JOIN pg_class c ON c.oid = a.attrelid
+       JOIN pg_namespace n ON n.oid = c.relnamespace
+       LEFT JOIN pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+      WHERE n.nspname = ANY(${S})
+        AND c.relkind IN ('r','v','m','f','p')
+        AND NOT c.relispartition
+        AND a.attnum > 0 AND NOT a.attisdropped
+      ORDER BY 1, 2, a.attnum`);
+	const conRows = await run(db, `SELECT con.conname AS name, con.contype::text AS type,
+            ns.nspname AS schema, rel.relname AS "table",
+            (SELECT json_agg(a.attname ORDER BY k.ord)
+               FROM unnest(con.conkey) WITH ORDINALITY k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = con.conrelid AND a.attnum = k.attnum) AS cols,
+            fns.nspname AS fschema, frel.relname AS ftable,
+            (SELECT json_agg(a.attname ORDER BY k.ord)
+               FROM unnest(con.confkey) WITH ORDINALITY k(attnum, ord)
+               JOIN pg_attribute a ON a.attrelid = con.confrelid AND a.attnum = k.attnum) AS fcols
+       FROM pg_constraint con
+       JOIN pg_class rel ON rel.oid = con.conrelid
+       JOIN pg_namespace ns ON ns.oid = rel.relnamespace
+       LEFT JOIN pg_class frel ON frel.oid = con.confrelid
+       LEFT JOIN pg_namespace fns ON fns.oid = frel.relnamespace
+      WHERE con.contype IN ('p','u','f')
+        AND con.conparentid = 0
+        AND (ns.nspname = ANY(${S}) OR fns.nspname = ANY(${S}))`);
+	const viewRows = await run(db, `SELECT DISTINCT ON (vc.oid, m.x[1]::int)
+            vn.nspname AS vschema, vc.relname AS vname, va.attname AS vcol,
+            tn.nspname AS tschema, tc.relname AS tname, ta.attname AS tcol
+       FROM pg_rewrite rw
+       JOIN pg_class vc ON vc.oid = rw.ev_class AND vc.relkind IN ('v','m')
+       JOIN pg_namespace vn ON vn.oid = vc.relnamespace
+       CROSS JOIN LATERAL regexp_matches(rw.ev_action::text,
+            ':resno (\\d+) :resname [^:]* :ressortgroupref \\d+ :resorigtbl (\\d+) :resorigcol (\\d+) :resjunk false', 'g')
+            WITH ORDINALITY AS m(x, ord)
+       JOIN pg_attribute va ON va.attrelid = vc.oid AND va.attnum = m.x[1]::int AND NOT va.attisdropped
+       JOIN pg_class tc ON tc.oid = m.x[2]::oid
+       JOIN pg_namespace tn ON tn.oid = tc.relnamespace
+       JOIN pg_attribute ta ON ta.attrelid = tc.oid AND ta.attnum = m.x[3]::int
+      WHERE vn.nspname = ANY(${S}) AND rw.rulename = '_RETURN' AND m.x[2]::oid <> 0
+      ORDER BY vc.oid, m.x[1]::int, m.ord DESC`);
+	const fnRows = await run(db, `SELECT n.nspname AS schema, p.proname AS name,
+            p.proretset AS returns_set, p.provolatile::text AS volatility,
+            format_type(p.prorettype, NULL) AS return_type,
+            rt.typtype::text AS return_typtype,
+            coalesce(p.proargmodes && ARRAY['o','b','t']::"char"[], false) AS has_out,
+            p.pronargdefaults AS n_defaults,
+            obj_description(p.oid, 'pg_proc') AS comment,
+            p.prorows::float8 AS rows,
+            CASE WHEN rt.typtype = 'd' AND rt.typname LIKE '%/%'
+                 THEN json_build_object('name', rt.typname, 'bytea', rt.typbasetype = 'bytea'::regtype) END AS ret_media,
+            (SELECT json_build_object('schema', n2.nspname, 'name', c2.relname)
+               FROM pg_type t2 JOIN pg_class c2 ON c2.oid = t2.typrelid JOIN pg_namespace n2 ON n2.oid = c2.relnamespace
+              WHERE p.pronargs = 1 AND t2.oid = p.proargtypes[0] AND c2.relkind IN ('r','v','m','f','p')) AS arg_rel,
+            (SELECT json_build_object('schema', n2.nspname, 'name', c2.relname)
+               FROM pg_type t2 JOIN pg_class c2 ON c2.oid = t2.typrelid JOIN pg_namespace n2 ON n2.oid = c2.relnamespace
+              WHERE t2.oid = p.prorettype AND c2.relkind IN ('r','v','m','f','p')) AS ret_rel,
+            (SELECT coalesce(json_agg(json_build_object(
+                       'name', coalesce(p.proargnames[t.i], ''),
+                       'type', format_type(t.typ, NULL),
+                       'mode', coalesce(p.proargmodes[t.i]::text, 'i')) ORDER BY t.i), '[]'::json)
+               FROM unnest(coalesce(p.proallargtypes, string_to_array(p.proargtypes::text, ' ')::oid[]))
+                    WITH ORDINALITY AS t(typ, i)
+              WHERE coalesce(p.proargmodes[t.i]::text, 'i') IN ('i','b','v')) AS args
+       FROM pg_proc p
+       JOIN pg_namespace n ON n.oid = p.pronamespace
+       JOIN pg_type rt ON rt.oid = p.prorettype
+      WHERE n.nspname = ANY(${S})
+        AND p.prokind = 'f'
+        AND NOT EXISTS (SELECT 1 FROM pg_depend d WHERE d.objid = p.oid AND d.deptype = 'e')
+      ORDER BY 1, 2`);
+	const mediaHandlers = (await run(db, `SELECT n.nspname AS schema, p.proname AS name,
+            (SELECT json_build_object('schema', n2.nspname, 'name', c2.relname)
+               FROM pg_type t2 JOIN pg_class c2 ON c2.oid = t2.typrelid JOIN pg_namespace n2 ON n2.oid = c2.relnamespace
+              WHERE t2.oid = p.proargtypes[0] AND c2.relkind IN ('r','v','m','f','p')) AS arg_rel,
+            rt.typbasetype = 'bytea'::regtype AS bytea
+       FROM pg_proc p
+       JOIN pg_namespace n ON n.oid = p.pronamespace
+       JOIN pg_type rt ON rt.oid = p.prorettype AND rt.typtype = 'd'
+      WHERE n.nspname = ANY(${S})
+        AND p.prokind = 'a' AND p.pronargs = 1 AND p.proname LIKE '%/%'
+        AND (p.proargtypes[0] = 'anyelement'::regtype
+             OR EXISTS (SELECT 1 FROM pg_type t3 JOIN pg_class c3 ON c3.oid = t3.typrelid WHERE t3.oid = p.proargtypes[0]))
+      ORDER BY 1, 2`)).map((h) => ({
+		schema: h.schema,
+		mediaType: h.name.toLowerCase(),
+		...h.arg_rel ? { argRelation: h.arg_rel } : {},
+		bytea: h.bytea
+	}));
+	const pk = /* @__PURE__ */ new Map();
+	const uniques = /* @__PURE__ */ new Map();
+	const foreignKeys = [];
+	for (const c of conRows) {
+		const key = relKey(c.schema, c.table);
+		if (c.type === "p") pk.set(key, c.cols);
+		else if (c.type === "u") uniques.set(key, [...uniques.get(key) ?? [], c.cols]);
+		else if (c.type === "f" && c.fschema && c.ftable && c.fcols) foreignKeys.push({
+			name: c.name,
+			schema: c.schema,
+			table: c.table,
+			cols: c.cols,
+			fschema: c.fschema,
+			ftable: c.ftable,
+			fcols: c.fcols
+		});
+	}
+	foreignKeys.push(...viewForeignKeys(foreignKeys, viewRows));
+	const colsByRel = /* @__PURE__ */ new Map();
+	for (const c of colRows) {
+		const key = relKey(c.schema, c.table);
+		const list = colsByRel.get(key) ?? [];
+		list.push({
+			name: c.name,
+			type: c.type,
+			nullable: c.nullable,
+			hasDefault: c.has_default,
+			defaultExpr: c.default_expr,
+			generated: c.generated,
+			comment: c.comment,
+			position: c.pos
+		});
+		colsByRel.set(key, list);
+	}
+	const relations = /* @__PURE__ */ new Map();
+	for (const r of relRows) {
+		const key = relKey(r.schema, r.name);
+		relations.set(key, {
+			schema: r.schema,
+			name: r.name,
+			kind: kindOf(r.kind),
+			columns: colsByRel.get(key) ?? [],
+			pk: pk.get(key) ?? [],
+			uniques: uniques.get(key) ?? [],
+			insertable: (r.bits & 8) === 8,
+			updatable: (r.bits & 4) === 4,
+			deletable: (r.bits & 16) === 16,
+			comment: r.comment
+		});
+	}
+	const functions = /* @__PURE__ */ new Map();
+	for (const f of fnRows) {
+		const nDefaults = f.n_defaults;
+		const args = f.args.map((a, i) => ({
+			name: a.name,
+			type: a.type,
+			hasDefault: i >= f.args.length - nDefaults,
+			variadic: a.mode === "v"
+		}));
+		const def = {
+			schema: f.schema,
+			name: f.name,
+			args,
+			returnType: f.return_type,
+			returnsSet: f.returns_set,
+			returnsComposite: f.has_out || f.return_typtype === "c" || f.return_type === "record",
+			returnsVoid: f.return_type === "void",
+			volatility: f.volatility === "i" ? "immutable" : f.volatility === "s" ? "stable" : "volatile",
+			comment: f.comment,
+			rows: f.rows,
+			...f.arg_rel ? { argRelation: f.arg_rel } : {},
+			...f.ret_rel ? { returnRelation: f.ret_rel } : {},
+			...f.ret_media && !f.returns_set ? { returnMediaType: f.ret_media } : {}
+		};
+		const key = relKey(f.schema, f.name);
+		functions.set(key, [...functions.get(key) ?? [], def]);
+	}
+	return {
+		schemas,
+		relations,
+		foreignKeys,
+		functions,
+		mediaHandlers
+	};
+};
+const sameCols = (a, b) => a.length === b.length && a.every((c) => b.includes(c));
+const isUnique = (rel, cols) => rel.pk.length > 0 && sameCols(rel.pk, cols) || rel.uniques.some((u) => sameCols(u, cols));
+const describe = (r) => {
+	const j = r.junction;
+	if (j) return `'${j.relation.name}' using '${j.fkFrom.name}' and '${j.fkTo.name}' (many-to-many)`;
+	if (r.computed) return `'${r.computed.name}' (computed, ${r.kind === "m2o" ? "many-to-one" : "one-to-many"})`;
+	return `'${r.fk.name}' (${r.kind === "m2o" ? "many-to-one" : r.kind === "o2o" ? "one-to-one" : "one-to-many"}) on ${r.fk.table}(${r.fk.cols.join(",")})`;
+};
+/** Find the relationships between `from` and the table/view named `target`. */
+const findRelationships = (cache, from, target, hint) => {
+	const out = [];
+	const rel = (schema, name) => cache.relations.get(relKey(schema, name));
+	for (const fk of cache.foreignKeys) {
+		const selfReference = fk.schema === fk.fschema && fk.table === fk.ftable;
+		if (fk.schema === from.schema && fk.table === from.name && fk.ftable === target && !selfReference) {
+			const to = rel(fk.fschema, fk.ftable);
+			if (to) out.push({
+				kind: "m2o",
+				from,
+				to,
+				fromCols: fk.cols,
+				toCols: fk.fcols,
+				fk
+			});
+		}
+		if (fk.schema === from.schema && fk.table === from.name && fk.cols.length === 1 && fk.cols[0] === target) {
+			const to = rel(fk.fschema, fk.ftable);
+			if (to) out.push({
+				kind: "m2o",
+				from,
+				to,
+				fromCols: fk.cols,
+				toCols: fk.fcols,
+				fk
+			});
+		}
+		if (fk.fschema === from.schema && fk.ftable === from.name && fk.table === target) {
+			const to = rel(fk.schema, fk.table);
+			if (to) out.push({
+				kind: isUnique(to, fk.cols) ? "o2o" : "o2m",
+				from,
+				to,
+				fromCols: fk.fcols,
+				toCols: fk.cols,
+				fk
+			});
+		}
+	}
+	for (const f of cache.functions.get(relKey(from.schema, target)) ?? []) {
+		if (f.argRelation?.schema !== from.schema || f.argRelation.name !== from.name || !f.returnRelation) continue;
+		const to = rel(f.returnRelation.schema, f.returnRelation.name);
+		if (!to) continue;
+		const fk = {
+			name: f.name,
+			schema: from.schema,
+			table: from.name,
+			cols: [],
+			fschema: to.schema,
+			ftable: to.name,
+			fcols: []
+		};
+		out.push({
+			kind: !f.returnsSet || f.rows === 1 ? "m2o" : "o2m",
+			from,
+			to,
+			fromCols: [],
+			toCols: [],
+			fk,
+			computed: f
+		});
+	}
+	for (const fk1 of cache.foreignKeys) {
+		if (fk1.fschema !== from.schema || fk1.ftable !== from.name) continue;
+		const junction = rel(fk1.schema, fk1.table);
+		if (!junction) continue;
+		for (const fk2 of cache.foreignKeys) {
+			if (fk2 === fk1) continue;
+			if (fk2.schema !== fk1.schema || fk2.table !== fk1.table) continue;
+			if (fk2.ftable !== target) continue;
+			const to = rel(fk2.fschema, fk2.ftable);
+			if (!to) continue;
+			out.push({
+				kind: "m2m",
+				from,
+				to,
+				fromCols: fk1.fcols,
+				toCols: fk2.fcols,
+				fk: fk1,
+				junction: {
+					relation: junction,
+					fkFrom: fk1,
+					fkTo: fk2
+				}
+			});
+		}
+	}
+	if (!hint) return out;
+	return out.filter((r) => {
+		if (r.junction) return r.junction.relation.name === hint || r.junction.fkFrom.name === hint || r.junction.fkTo.name === hint;
+		return r.fk.name === hint || r.fk.cols.includes(hint) || r.fk.fcols.includes(hint);
+	});
+};
+/**
+* Resolve exactly one relationship or throw PostgREST-style PGRST200/PGRST201.
+* `target` may also be a table that is not related at all (→ PGRST200).
+*/
+const resolveRelationship = (cache, from, target, hint) => {
+	const found = findRelationships(cache, from, target, hint);
+	if (found.length === 1) return found[0];
+	if (found.length === 0) throw new PgRestError(400, "PGRST200", `Could not find a relationship between '${from.name}' and '${target}' in the schema cache`, hint ? `Searched for a foreign key relationship between '${from.name}' and '${target}' using the hint '${hint}' in the schema '${from.schema}', but no matches were found.` : `Searched for a foreign key relationship between '${from.name}' and '${target}' in the schema '${from.schema}', but no matches were found.`, null);
+	throw new PgRestError(300, "PGRST201", `Could not embed because more than one relationship was found for '${from.name}' and '${target}'`, JSON.stringify(found.map((r) => describe(r))), `Try changing '${target}' to one of the following: ${found.map((r) => `'${target}!${r.junction ? r.junction.relation.name : r.fk.name}'`).join(", ")}. Find the desired relationship in the 'details' key.`);
+};
+/** Look up a relation by (optional) schema and name, or throw PGRST205. */
+const getRelation = (cache, schema, name) => {
+	const rel = cache.relations.get(relKey(schema, name));
+	if (!rel) throw new PgRestError(404, "PGRST205", `Could not find the table '${schema}.${name}' in the schema cache`, null, suggest(cache, schema, name));
+	return rel;
+};
+const suggest = (cache, schema, name) => {
+	let best;
+	for (const r of cache.relations.values()) {
+		if (r.schema !== schema) continue;
+		const d = levenshtein(name.toLowerCase(), r.name.toLowerCase());
+		if (d <= Math.max(1, Math.floor(name.length / 4)) && (!best || d < best.d)) best = {
+			name: r.name,
+			d
+		};
+	}
+	return best ? `Perhaps you meant the table '${schema}.${best.name}'` : null;
+};
+const levenshtein = (a, b) => {
+	const dp = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i++) {
+		let prev = dp[0];
+		dp[0] = i;
+		for (let j = 1; j <= b.length; j++) {
+			const tmp = dp[j];
+			dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+			prev = tmp;
+		}
+	}
+	return dp[b.length];
+};
+
+//#endregion
+//#region src/media.ts
+const choiceFor = (mediaType, bytea, extra) => ({
+	mediaType,
+	contentType: mediaType === "*/*" || bytea ? mediaType === "*/*" ? "application/octet-stream" : mediaType : `${mediaType}; charset=utf-8`,
+	bytea,
+	...extra
+});
+/** Aggregates in the exposed schemas that render rows of `relation` (or of any type) as a custom media type. */
+const aggregateChoices = (cache, schema, relation, allowTyped) => cache.mediaHandlers.filter((h) => h.schema === schema).filter((h) => h.argRelation ? allowTyped && h.argRelation.schema === relation.schema && h.argRelation.name === relation.name : true).map((h) => choiceFor(h.mediaType, h.bytea, {
+	aggregate: quoteQualified(h.schema, h.mediaType),
+	...h.argRelation ? { rowType: quoteQualified(h.argRelation.schema, h.argRelation.name) } : {}
+}));
+/**
+* The custom media types a request can be answered with. Handlers that take a specific table apply only when
+* the request returns whole rows of it (no `select`); `anyelement` handlers apply to any rows.
+*/
+const mediaChoices = (cache, schema, target, hasSelect) => {
+	if (cache.mediaHandlers.length === 0 && ![...cache.functions.values()].some((fs) => fs.some((f) => f.returnMediaType))) return [];
+	if (target.type === "table") {
+		const rel = cache.relations.get(relKey(schema, target.name));
+		return rel ? aggregateChoices(cache, schema, rel, !hasSelect) : [];
+	}
+	const fns = cache.functions.get(relKey(schema, target.name)) ?? [];
+	const out = [];
+	for (const f of fns) if (f.returnMediaType) out.push(choiceFor(f.returnMediaType.name.toLowerCase(), f.returnMediaType.bytea, {}));
+	else if (f.returnRelation && f.returnsSet) out.push(...aggregateChoices(cache, schema, f.returnRelation, !hasSelect));
+	if (fns.some((f) => !f.returnsSet && !f.returnsComposite && !f.returnsVoid)) {
+		const any = cache.mediaHandlers.find((h) => h.schema === schema && h.mediaType === "*/*" && !h.argRelation);
+		if (any) out.push(choiceFor("*/*", any.bytea, {}));
+	}
+	return out;
+};
+
+//#endregion
+//#region src/openapi.ts
+/** Map a Postgres `format_type` string to an OpenAPI 2.0 schema fragment. */
+const pgTypeToOpenApi = (pgType) => {
+	const t = pgType.trim();
+	if (t.endsWith("[]")) return {
+		type: "array",
+		items: pgTypeToOpenApi(t.slice(0, -2))
+	};
+	const base = t.replace(/\(.*\)$/, "");
+	switch (base) {
+		case "smallint":
+		case "integer": return {
+			type: "integer",
+			format: base
+		};
+		case "bigint": return {
+			type: "integer",
+			format: "bigint"
+		};
+		case "numeric":
+		case "decimal": return {
+			type: "number",
+			format: "numeric"
+		};
+		case "real": return {
+			type: "number",
+			format: "real"
+		};
+		case "double precision": return {
+			type: "number",
+			format: "double precision"
+		};
+		case "boolean": return {
+			type: "boolean",
+			format: "boolean"
+		};
+		case "json":
+		case "jsonb": return { format: base };
+		case "uuid":
+		case "text":
+		case "date":
+		case "bytea":
+		case "money":
+		case "interval": return {
+			type: "string",
+			format: base
+		};
+		case "character varying":
+		case "character": return {
+			type: "string",
+			format: t
+		};
+		case "timestamp with time zone":
+		case "timestamp without time zone":
+		case "time with time zone":
+		case "time without time zone": return {
+			type: "string",
+			format: base
+		};
+		default: return {
+			type: "string",
+			format: t
+		};
+	}
+};
+const columnSchema = (rel, c) => {
+	const s = pgTypeToOpenApi(c.type);
+	const notes = [];
+	if (c.comment) notes.push(c.comment);
+	if (rel.pk.includes(c.name)) notes.push("Note:\nThis is a Primary Key.<pk/>");
+	if (notes.length) s["description"] = notes.join("\n\n");
+	if (c.hasDefault && c.defaultExpr && !c.defaultExpr.includes("nextval(")) s["default"] = c.defaultExpr;
+	return s;
+};
+const FILTER_NOTE = "Filter using PostgREST operators, e.g. `eq.1`, `gt.5`, `in.(a,b)`, `is.null`";
+/** Build the Swagger 2.0 document PostgREST serves at `/`. */
+const buildOpenApi = (cache, schema, opts) => {
+	let host = "localhost";
+	let scheme = "http";
+	try {
+		const u = new URL(opts.serverUrl);
+		host = u.host;
+		scheme = u.protocol.replace(":", "");
+	} catch {}
+	const relations = [...cache.relations.values()].filter((r) => r.schema === schema).sort((a, b) => a.name.localeCompare(b.name));
+	const functions = [...cache.functions.values()].flat().filter((f) => f.schema === schema).sort((a, b) => a.name.localeCompare(b.name));
+	const parameters = {
+		preferReturn: {
+			name: "Prefer",
+			description: "Preference",
+			required: false,
+			in: "header",
+			type: "string",
+			enum: [
+				"return=representation",
+				"return=minimal",
+				"return=headers-only"
+			]
+		},
+		preferCount: {
+			name: "Prefer",
+			description: "Preference",
+			required: false,
+			in: "header",
+			type: "string",
+			enum: ["count=none"]
+		},
+		preferPost: {
+			name: "Prefer",
+			description: "Preference",
+			required: false,
+			in: "header",
+			type: "string",
+			enum: [
+				"return=representation",
+				"return=minimal",
+				"return=headers-only",
+				"resolution=ignore-duplicates",
+				"resolution=merge-duplicates"
+			]
+		},
+		select: {
+			name: "select",
+			description: "Filtering Columns",
+			required: false,
+			in: "query",
+			type: "string"
+		},
+		on_conflict: {
+			name: "on_conflict",
+			description: "On Conflict",
+			required: false,
+			in: "query",
+			type: "string"
+		},
+		order: {
+			name: "order",
+			description: "Ordering",
+			required: false,
+			in: "query",
+			type: "string"
+		},
+		range: {
+			name: "Range",
+			description: "Limiting and Pagination",
+			required: false,
+			in: "header",
+			type: "string"
+		},
+		rangeUnit: {
+			name: "Range-Unit",
+			description: "Limiting and Pagination",
+			required: false,
+			default: "items",
+			in: "header",
+			type: "string"
+		},
+		offset: {
+			name: "offset",
+			description: "Limiting and Pagination",
+			required: false,
+			in: "query",
+			type: "string"
+		},
+		limit: {
+			name: "limit",
+			description: "Limiting and Pagination",
+			required: false,
+			in: "query",
+			type: "string"
+		}
+	};
+	const paths = { "/": { get: {
+		tags: ["Introspection"],
+		summary: "OpenAPI description (this document)",
+		produces: ["application/openapi+json", "application/json"],
+		responses: { "200": { description: "OK" } }
+	} } };
+	const definitions = {};
+	for (const rel of relations) {
+		const props = {};
+		const required = [];
+		for (const c of rel.columns) {
+			props[c.name] = columnSchema(rel, c);
+			if (!c.nullable && !c.hasDefault) required.push(c.name);
+		}
+		definitions[rel.name] = {
+			type: "object",
+			...required.length ? { required } : {},
+			properties: props,
+			...rel.comment ? { description: rel.comment } : {}
+		};
+		const filterRefs = [];
+		for (const c of rel.columns) {
+			const key = `rowFilter.${rel.name}.${c.name}`;
+			parameters[key] = {
+				name: c.name,
+				required: false,
+				in: "query",
+				type: "string",
+				description: FILTER_NOTE
+			};
+			filterRefs.push({ $ref: `#/parameters/${key}` });
+		}
+		const bodyKey = `body.${rel.name}`;
+		parameters[bodyKey] = {
+			name: rel.name,
+			description: rel.name,
+			required: false,
+			in: "body",
+			schema: { $ref: `#/definitions/${rel.name}` }
+		};
+		const ref = `#/definitions/${rel.name}`;
+		const op = { get: {
+			tags: [rel.name],
+			parameters: [
+				...filterRefs,
+				{ $ref: "#/parameters/select" },
+				{ $ref: "#/parameters/order" },
+				{ $ref: "#/parameters/range" },
+				{ $ref: "#/parameters/rangeUnit" },
+				{ $ref: "#/parameters/offset" },
+				{ $ref: "#/parameters/limit" },
+				{ $ref: "#/parameters/preferCount" }
+			],
+			responses: {
+				"200": {
+					description: "OK",
+					schema: {
+						type: "array",
+						items: { $ref: ref }
+					}
+				},
+				"206": { description: "Partial Content" }
+			},
+			...rel.comment ? { summary: rel.comment } : {}
+		} };
+		if (rel.insertable) op["post"] = {
+			tags: [rel.name],
+			parameters: [
+				{ $ref: `#/parameters/${bodyKey}` },
+				{ $ref: "#/parameters/select" },
+				{ $ref: "#/parameters/preferPost" }
+			],
+			responses: { "201": { description: "Created" } }
+		};
+		if (rel.deletable) op["delete"] = {
+			tags: [rel.name],
+			parameters: [...filterRefs, { $ref: "#/parameters/preferReturn" }],
+			responses: { "204": { description: "No Content" } }
+		};
+		if (rel.updatable) op["patch"] = {
+			tags: [rel.name],
+			parameters: [
+				...filterRefs,
+				{ $ref: `#/parameters/${bodyKey}` },
+				{ $ref: "#/parameters/preferReturn" }
+			],
+			responses: { "204": { description: "No Content" } }
+		};
+		paths[`/${rel.name}`] = op;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const fn of functions) {
+		if (seen.has(fn.name)) continue;
+		seen.add(fn.name);
+		paths[`/rpc/${fn.name}`] = rpcPath(fn);
+	}
+	return {
+		swagger: "2.0",
+		info: {
+			title: `standard ${schema} schema`,
+			description: "",
+			version: "16"
+		},
+		host,
+		basePath: opts.basePath || "/",
+		schemes: [scheme],
+		consumes: [
+			"application/json",
+			"application/vnd.pgrst.object+json;nulls=stripped",
+			"application/vnd.pgrst.object+json",
+			"text/csv"
+		],
+		produces: [
+			"application/json",
+			"application/vnd.pgrst.object+json;nulls=stripped",
+			"application/vnd.pgrst.object+json",
+			"text/csv"
+		],
+		paths,
+		definitions,
+		parameters,
+		externalDocs: {
+			description: "PostgREST Documentation",
+			url: "https://postgrest.org/en/v16/references/api.html"
+		}
+	};
+};
+const rpcPath = (fn) => {
+	const props = {};
+	const required = [];
+	for (const a of fn.args) {
+		if (!a.name) continue;
+		props[a.name] = pgTypeToOpenApi(a.type);
+		if (!a.hasDefault) required.push(a.name);
+	}
+	const path = { post: {
+		tags: [`(rpc) ${fn.name}`],
+		produces: [
+			"application/json",
+			"application/vnd.pgrst.object+json;nulls=stripped",
+			"application/vnd.pgrst.object+json"
+		],
+		parameters: [{
+			name: "args",
+			required: true,
+			in: "body",
+			schema: {
+				type: "object",
+				properties: props,
+				...required.length ? { required } : {}
+			}
+		}],
+		responses: { "200": { description: "OK" } },
+		...fn.comment ? { summary: fn.comment } : {}
+	} };
+	if (fn.volatility !== "volatile") path["get"] = {
+		tags: [`(rpc) ${fn.name}`],
+		produces: [
+			"application/json",
+			"application/vnd.pgrst.object+json;nulls=stripped",
+			"application/vnd.pgrst.object+json"
+		],
+		parameters: fn.args.filter((a) => a.name).map((a) => ({
+			name: a.name,
+			required: !a.hasDefault,
+			in: "query",
+			...pgTypeToOpenApi(a.type)
+		})),
+		responses: { "200": { description: "OK" } }
+	};
+	return path;
+};
+
+//#endregion
+//#region src/sql/filters.ts
+/** `"alias"."column"->'a'->>'b'` */
+const fieldSql = (alias, field$1) => {
+	let sql = `${quoteIdent(alias)}.${quoteIdent(field$1.name)}`;
+	for (const step of field$1.json) sql += ` ${step.arrow} ${step.isIndex ? String(Number(step.key)) : literal(step.key)}`;
+	return sql;
+};
+const COMPARISON = {
+	eq: "=",
+	neq: "<>",
+	gt: ">",
+	gte: ">=",
+	lt: "<",
+	lte: "<=",
+	like: "LIKE",
+	ilike: "ILIKE",
+	match: "~",
+	imatch: "~*",
+	cs: "@>",
+	cd: "<@",
+	ov: "&&",
+	sl: "<<",
+	sr: ">>",
+	nxl: "&>",
+	nxr: "&<",
+	adj: "-|-"
+};
+const FTS_FUNCTIONS = {
+	fts: "to_tsquery",
+	plfts: "plainto_tsquery",
+	phfts: "phraseto_tsquery",
+	wfts: "websearch_to_tsquery"
+};
+const columnType = (rel, field$1) => field$1.json.length === 0 ? rel?.columns.find((c) => c.name === field$1.name)?.type : void 0;
+const patternValue = (op, v) => op === "like" || op === "ilike" ? v.replace(/\*/g, "%") : v;
+/** SQL boolean expression for one filter. */
+const filterSql = (f, alias, rel) => {
+	const lhs = fieldSql(alias, f.field);
+	let expr;
+	switch (f.op) {
+		case "in": {
+			const list = f.value;
+			expr = list.length === 0 ? "FALSE" : `${lhs} IN (${list.map(literal).join(", ")})`;
+			break;
+		}
+		case "is":
+			switch (f.value) {
+				case "null":
+					expr = `${lhs} IS NULL`;
+					break;
+				case "not_null":
+					expr = `${lhs} IS NOT NULL`;
+					break;
+				case "true":
+					expr = `${lhs} IS TRUE`;
+					break;
+				case "false":
+					expr = `${lhs} IS FALSE`;
+					break;
+				default: expr = `${lhs} IS UNKNOWN`;
+			}
+			break;
+		case "isdistinct":
+			expr = `${lhs} IS DISTINCT FROM ${literal(f.value)}`;
+			break;
+		case "fts":
+		case "plfts":
+		case "phfts":
+		case "wfts": {
+			const fn = FTS_FUNCTIONS[f.op];
+			const cfg = f.lang ? `${literal(f.lang)}, ` : "";
+			expr = `${columnType(rel, f.field) === "tsvector" ? lhs : `to_tsvector(${cfg}${lhs})`} @@ ${fn}(${cfg}${literal(f.value)})`;
+			break;
+		}
+		default: {
+			const sqlOp = COMPARISON[f.op];
+			const value = patternValue(f.op, f.value);
+			expr = f.quantifier ? `${lhs} ${sqlOp} ${f.quantifier.toUpperCase()} (${literal(value)})` : `${lhs} ${sqlOp} ${literal(value)}`;
+		}
+	}
+	return f.negate ? `NOT (${expr})` : expr;
+};
+const nodeSql = (node, alias, rel) => {
+	if (node.kind === "filter") return filterSql(node, alias, rel);
+	const joiner = node.op === "and" ? " AND " : " OR ";
+	const wrapped = `(${node.children.map((c) => nodeSql(c, alias, rel)).join(joiner)})`;
+	return node.negate ? `NOT ${wrapped}` : wrapped;
+};
+const whereSql = (nodes, alias, rel) => nodes.map((n) => nodeSql(n, alias, rel));
+
+//#endregion
+//#region src/sql/read.ts
+const ROOT_ALIAS = "pgrst_root";
+var Aliases = class {
+	n = 0;
+	next(prefix) {
+		return `${prefix}${++this.n}`;
+	}
+};
+const fieldExpr = (item, alias) => {
+	const base = fieldSql(alias, item.field);
+	const expr = item.cast ? `${base}::${item.cast}` : base;
+	return !item.cast && item.field.json.length === 0 && !item.alias ? expr : `${expr} AS ${quoteIdent(outputName(item))}`;
+};
+const aggregateExpr = (item, alias) => {
+	const arg = item.field ? fieldSql(alias, item.field) : "*";
+	let expr = `${item.fn}(${arg})`;
+	if (item.cast) expr = `(${expr})::${item.cast}`;
+	return `${expr} AS ${quoteIdent(outputName(item))}`;
+};
+/** Output column names produced by a list of select items (used for spreads). */
+const itemNames = (ctx, items, rel) => {
+	const out = [];
+	for (const it of items) if (it.kind === "star") out.push(...rel.columns.map((c) => c.name));
+	else if (it.kind === "field" || it.kind === "aggregate") out.push(outputName(it));
+	else if (it.items.length === 0) continue;
+	else if (it.spread) out.push(...itemNames(ctx, it.items, resolveRelationship(ctx.cache, rel, it.target, it.hint).to));
+	else out.push(it.alias ?? it.target);
+	return out;
+};
+const orderClause = (ctx, terms, rel, alias, items) => {
+	if (terms.length === 0) return "";
+	const q = quoteIdent;
+	return `ORDER BY ${terms.map((t) => {
+		const tail = `${t.dir.toUpperCase()}${t.nulls ? ` NULLS ${t.nulls.toUpperCase()}` : ""}`;
+		if (!t.relation) return `${fieldSql(alias, t.field)} ${tail}`;
+		const embed = items.find((i) => i.kind === "embed" && (i.alias ?? i.target) === t.relation);
+		if (!embed) throw new PgRestError(400, "PGRST108", `'${t.relation}' is not an embedded resource in this request`, null, `Verify that '${t.relation}' is included in the 'select' query parameter.`);
+		const r = resolveRelationship(ctx.cache, rel, embed.target, embed.hint);
+		if (r.kind !== "m2o" && r.kind !== "o2o") throw new PgRestError(400, "PGRST118", `A related order on '${t.relation}' is not possible`, `'${rel.name}' and '${embed.target}' do not form a many-to-one or one-to-one relationship`, null);
+		const selected = embed.items.filter((i) => i.kind !== "embed");
+		if (selected.length > 0 && !selected.some((i) => i.kind === "star" || i.kind === "field" && i.field.name === t.field.name)) throw new PgRestError(400, "42703", `column ${rel.name}_${embed.target}_1.${t.field.name} does not exist`, null, null);
+		const o = ctx.aliases.next("pgrst_o");
+		if (r.computed) return `(SELECT ${fieldSql(o, t.field)} FROM ${quoteQualified(r.computed.schema, r.computed.name)}(${q(alias)}) AS ${q(o)} LIMIT 1) ${tail}`;
+		const cond = r.toCols.map((c, i) => `${q(o)}.${q(c)} = ${q(alias)}.${q(r.fromCols[i])}`).join(" AND ");
+		return `(SELECT ${fieldSql(o, t.field)} FROM ${quoteQualified(r.to.schema, r.to.name)} AS ${q(o)} WHERE ${cond} LIMIT 1) ${tail}`;
+	}).join(", ")}`;
+};
+const buildItems = (ctx, items, rel, alias, path) => {
+	const cols = [];
+	const joins = [];
+	const groupBy = [];
+	const aggregated = items.some((i) => i.kind === "aggregate");
+	for (const item of items) switch (item.kind) {
+		case "star":
+			if (aggregated) for (const c of rel.columns) {
+				const e = `${quoteIdent(alias)}.${quoteIdent(c.name)}`;
+				cols.push(e);
+				groupBy.push(e);
+			}
+			else cols.push(`${quoteIdent(alias)}.*`);
+			break;
+		case "field":
+			cols.push(fieldExpr(item, alias));
+			if (aggregated) groupBy.push(fieldSql(alias, item.field));
+			break;
+		case "aggregate":
+			cols.push(aggregateExpr(item, alias));
+			break;
+		case "embed": {
+			const e = buildEmbed(ctx, item, rel, alias, path);
+			cols.push(...e.cols);
+			joins.push(e.join);
+			if (aggregated) groupBy.push(...e.group);
+			break;
+		}
+	}
+	return {
+		cols,
+		joins,
+		groupBy,
+		aggregated
+	};
+};
+const presenceConditions = (params, joins) => (params?.presence ?? []).map((p) => {
+	const j = joins.find((x) => x.name === p.embed);
+	if (!j) throw new PgRestError(400, "PGRST108", `'${p.embed}' is not an embedded resource in this request`, null, `Verify that '${p.embed}' is included in the 'select' query parameter.`);
+	return `${quoteIdent(j.alias)}.j IS ${p.present ? "NOT " : ""}NULL`;
+});
+const paging = (limit, offset) => {
+	let s = "";
+	if (limit !== void 0) s += ` LIMIT ${Math.trunc(limit)}`;
+	if (offset !== void 0 && offset > 0) s += ` OFFSET ${Math.trunc(offset)}`;
+	return s;
+};
+const buildEmbed = (ctx, item, parentRel, parentAlias, path) => {
+	const relationship = resolveRelationship(ctx.cache, parentRel, item.target, item.hint);
+	const name = item.alias ?? item.target;
+	const childPath = [...path, name];
+	const params = ctx.query.embeds.get(childPath.join("."));
+	const toOne = relationship.kind === "m2o" || relationship.kind === "o2o";
+	const child = relationship.to;
+	const cAlias = ctx.aliases.next("pgrst_c");
+	const eAlias = ctx.aliases.next("pgrst_j");
+	const inner = buildItems(ctx, item.items, child, cAlias, childPath);
+	const hasCols = inner.cols.length > 0;
+	const q = quoteIdent;
+	const conds = [];
+	let from;
+	if (relationship.computed) {
+		const fn = relationship.computed;
+		from = `${quoteQualified(fn.schema, fn.name)}(${q(parentAlias)}) AS ${q(cAlias)}`;
+		conds.push("TRUE");
+	} else if (relationship.junction) {
+		const j = relationship.junction;
+		const jAlias = ctx.aliases.next("pgrst_m");
+		const onTo = j.fkTo.cols.map((c, i) => `${q(jAlias)}.${q(c)} = ${q(cAlias)}.${q(j.fkTo.fcols[i])}`);
+		from = `${quoteQualified(child.schema, child.name)} AS ${q(cAlias)} JOIN ${quoteQualified(j.relation.schema, j.relation.name)} AS ${q(jAlias)} ON ${onTo.join(" AND ")}`;
+		conds.push(...j.fkFrom.cols.map((c, i) => `${q(jAlias)}.${q(c)} = ${q(parentAlias)}.${q(j.fkFrom.fcols[i])}`));
+	} else {
+		from = `${quoteQualified(child.schema, child.name)} AS ${q(cAlias)}`;
+		conds.push(...relationship.toCols.map((c, i) => `${q(cAlias)}.${q(c)} = ${q(parentAlias)}.${q(relationship.fromCols[i])}`));
+	}
+	if (inner.joins.length) from += ` ${inner.joins.map((j) => j.sql).join(" ")}`;
+	conds.push(...params ? whereSql(params.filters, cAlias, child) : []);
+	conds.push(...presenceConditions(params, inner.joins));
+	const order$1 = params ? orderClause(ctx, params.order, child, cAlias, item.items) : "";
+	const page = paging(params?.limit, params?.offset);
+	const sel = hasCols ? inner.cols.join(", ") : "1";
+	const groupSql = inner.aggregated && inner.groupBy.length ? ` GROUP BY ${inner.groupBy.join(", ")}` : "";
+	const body = `SELECT ${sel} FROM ${from} WHERE ${conds.join(" AND ")}${groupSql}${order$1 ? ` ${order$1}` : ""}${page}`;
+	const J = "jsonb";
+	const joinKw = item.join === "inner" ? "JOIN LATERAL" : "LEFT JOIN LATERAL";
+	if (item.spread) {
+		const names = itemNames(ctx, item.items, child);
+		if (toOne) {
+			const lateral$2 = `${joinKw} (${body}${page ? "" : " LIMIT 1"}) AS ${q(eAlias)} ON TRUE`;
+			const refs$1 = names.map((n) => `${q(eAlias)}.${q(n)}`);
+			return {
+				cols: names.map((n, i) => `${refs$1[i]} AS ${q(n)}`),
+				join: {
+					sql: lateral$2,
+					alias: eAlias,
+					name,
+					inner: item.join === "inner"
+				},
+				group: refs$1
+			};
+		}
+		if (inner.aggregated) throw new PgRestError(400, "PGRST127", "Feature not implemented", "Aggregates are not implemented for one-to-many or many-to-many spreads.", null);
+		const agg = names.map((n) => `coalesce(${J}_agg(_r.${q(n)}), '[]'::${J}) AS ${q(n)}`).join(", ");
+		const having = item.join === "inner" ? " HAVING count(*) > 0" : "";
+		const lateral$1 = `${joinKw} (SELECT ${agg || "1"} FROM (${body}) AS _r${having}) AS ${q(eAlias)} ON TRUE`;
+		const refs = names.map((n) => `${q(eAlias)}.${q(n)}`);
+		return {
+			cols: names.map((n, i) => `${refs[i]} AS ${q(n)}`),
+			join: {
+				sql: lateral$1,
+				alias: eAlias,
+				name,
+				inner: item.join === "inner"
+			},
+			group: refs
+		};
+	}
+	if (toOne) {
+		const lateral$1 = `${joinKw} (SELECT to_${J}(_r) AS j FROM (${body}) AS _r LIMIT 1) AS ${q(eAlias)} ON TRUE`;
+		return {
+			cols: hasCols ? [`${q(eAlias)}.j AS ${q(name)}`] : [],
+			join: {
+				sql: lateral$1,
+				alias: eAlias,
+				name,
+				inner: item.join === "inner"
+			},
+			group: hasCols ? [`${q(eAlias)}.j`] : []
+		};
+	}
+	const lateral = `${joinKw} (SELECT ${J}_agg(_r) AS j FROM (${body}) AS _r${item.join === "inner" ? " HAVING count(*) > 0" : ""}) AS ${q(eAlias)} ON TRUE`;
+	return {
+		cols: hasCols ? [`coalesce(${q(eAlias)}.j, '[]'::${J}) AS ${q(name)}`] : [],
+		join: {
+			sql: lateral,
+			alias: eAlias,
+			name,
+			inner: item.join === "inner"
+		},
+		group: hasCols ? [`${q(eAlias)}.j`] : []
+	};
+};
+/** Build the SELECT (and matching COUNT) for a read request. */
+const buildRead = (opts) => {
+	const ctx = {
+		cache: opts.cache,
+		query: opts.query,
+		aliases: new Aliases()
+	};
+	const built = buildItems(ctx, opts.query.select, opts.rel, ROOT_ALIAS, []);
+	const where = [...whereSql(opts.query.root.filters, ROOT_ALIAS, opts.rel), ...presenceConditions(opts.query.root, built.joins)];
+	const whereClause = where.length ? ` WHERE ${where.join(" AND ")}` : "";
+	const fromClause = `${opts.from} AS ${quoteIdent(ROOT_ALIAS)}`;
+	const joinSql = built.joins.map((j) => j.sql).join(" ");
+	const groupClause = built.aggregated && built.groupBy.length ? ` GROUP BY ${built.groupBy.join(", ")}` : "";
+	const order$1 = orderClause(ctx, opts.query.root.order, opts.rel, ROOT_ALIAS, opts.query.select);
+	const unpaged = `SELECT ${built.cols.length ? built.cols.join(", ") : "1"} FROM ${fromClause}${joinSql ? ` ${joinSql}` : ""}${whereClause}${groupClause}`;
+	const rows = `${unpaged}${order$1 ? ` ${order$1}` : ""}${paging(opts.limit, opts.offset)}`;
+	let count;
+	if (built.aggregated) count = `SELECT count(*) FROM (${unpaged}) AS _c`;
+	else if (built.joins.some((j) => j.inner) || (opts.query.root.presence.length ?? 0) > 0) count = `SELECT count(*) FROM ${fromClause} ${joinSql}${whereClause}`;
+	else count = `SELECT count(*) FROM ${fromClause}${whereClause}`;
+	return {
+		rows,
+		count,
+		unpaged
+	};
+};
+
+//#endregion
+//#region src/sql/rpc.ts
+const SINGLE_BODY_TYPES = new Set([
+	"json",
+	"jsonb",
+	"text",
+	"bytea"
+]);
+const isSingleUnnamedParam = (fn) => fn.args.length === 1 && fn.args[0].name === "" && SINGLE_BODY_TYPES.has(fn.args[0].type);
+/** PostgREST's spelling used in PGRST203: `schema.fn(a => integer, b => text)`. */
+const arrowSignature = (fn) => `${fn.schema}.${fn.name}(${fn.args.map((a) => `${a.name} => ${a.type}`).join(", ")})`;
+/** Similarity of two names, 1 for equal; PostgREST suggests the closest name above ~0.75. */
+const similarity = (a, b) => 1 - levenshtein(a.toLowerCase(), b.toLowerCase()) / Math.max(a.length, b.length, 1);
+const SUGGEST_AT = .75;
+/** The "Perhaps you meant ..." hint of PGRST202. */
+const functionHint = (cache, schema, name, candidates, provided) => {
+	if (candidates.length > 0) {
+		let best$1;
+		for (const fn of candidates) {
+			let score = 0;
+			for (const p of provided) if (fn.args.some((a) => a.name === p)) score += 2;
+			else if (fn.args.some((a) => similarity(a.name, p) >= SUGGEST_AT)) score += 1;
+			if (score > 0 && (!best$1 || score > best$1.score)) best$1 = {
+				fn,
+				score
+			};
+		}
+		return best$1 ? `Perhaps you meant to call the function ${schema}.${name}(${best$1.fn.args.map((a) => a.name).sort().join(", ")})` : null;
+	}
+	let best;
+	for (const fns of cache.functions.values()) {
+		const fn = fns[0];
+		if (!fn || fn.schema !== schema) continue;
+		const score = similarity(name, fn.name);
+		if (score >= SUGGEST_AT && (!best || score > best.score)) best = {
+			name: fn.name,
+			score
+		};
+	}
+	return best ? `Perhaps you meant to call the function ${schema}.${best.name}` : null;
+};
+/**
+* Pick the function to call from the argument names the client supplied.
+* `rawBody` is true when a request body that is not a JSON object was given;
+* `post` tells whether the function was invoked with POST (which also allows a single unnamed parameter).
+*/
+const resolveFunction = (cache, schema, name, provided, hasBody, post = true) => {
+	const candidates = cache.functions.get(relKey(schema, name)) ?? [];
+	const names = [...provided].sort();
+	const params = names.length === 0 ? "without parameters" : `with parameter${names.length === 1 ? "" : "s"} ${names.join(", ")}`;
+	const notFound = () => new PgRestError(404, "PGRST202", names.length === 0 ? `Could not find the function ${schema}.${name} without parameters in the schema cache` : `Could not find the function ${schema}.${name}(${names.join(", ")}) in the schema cache`, `Searched for the function ${schema}.${name} ${params}${post ? " or with a single unnamed json/jsonb parameter" : ""}, but no matches were found in the schema cache.`, functionHint(cache, schema, name, candidates, provided));
+	if (candidates.length === 0) throw notFound();
+	const named = candidates.filter((fn) => {
+		const argNames = new Set(fn.args.map((a) => a.name));
+		for (const p of provided) if (!argNames.has(p)) return false;
+		return fn.args.every((a) => a.hasDefault || provided.has(a.name));
+	});
+	const single = hasBody ? candidates.filter(isSingleUnnamedParam) : [];
+	const matches = provided.size === 0 && hasBody && single.length > 0 ? single : [...named, ...single.filter((s) => !named.includes(s))];
+	if (matches.length === 0) throw notFound();
+	if (matches.length === 1) return matches[0];
+	const exact = matches.filter((fn) => fn.args.length === provided.size);
+	if (exact.length === 1) return exact[0];
+	throw new PgRestError(300, "PGRST203", `Could not choose the best candidate function between: ${matches.map(arrowSignature).sort().join(", ")}`, null, "Try renaming the parameters or the function itself in the database so function overloading can be resolved");
+};
+const stripQuotes = (s) => s.replace(/^"|"$/g, "");
+/** Find the table a composite return type refers to, if it is an exposed relation. */
+const relationOfReturnType = (cache, fn) => {
+	if (!fn.returnsComposite) return void 0;
+	const t = fn.returnType.replace(/\[\]$/, "");
+	const dot = t.indexOf(".");
+	if (dot > 0) return cache.relations.get(relKey(stripQuotes(t.slice(0, dot)), stripQuotes(t.slice(dot + 1))));
+	const bare = stripQuotes(t);
+	const inOwn = cache.relations.get(relKey(fn.schema, bare));
+	if (inOwn) return inOwn;
+	for (const r of cache.relations.values()) if (r.name === bare) return r;
+};
+const syntheticRelation = (fn) => ({
+	schema: fn.schema,
+	name: fn.name,
+	kind: "view",
+	columns: [],
+	pk: [],
+	uniques: [],
+	insertable: false,
+	updatable: false,
+	deletable: false,
+	comment: null
+});
+/**
+* Build the SQL that calls `fn`. Arguments travel as one JSON text (`$1`) and
+* are converted by `json_to_record` using the declared types, so values are
+* never interpolated into SQL.
+*/
+const buildRpc = (cache, fn, provided, rawBody) => {
+	const fnRef = quoteQualified(fn.schema, fn.name);
+	let args;
+	let usesBody = false;
+	let from = "";
+	if (rawBody && isSingleUnnamedParam(fn)) {
+		args = `($1::text)::${fn.args[0].type}`;
+		usesBody = true;
+	} else {
+		const used = fn.args.filter((a) => provided.includes(a.name));
+		args = used.map((a) => `${a.variadic ? "VARIADIC " : ""}${quoteIdent(a.name)} := _args.${quoteIdent(a.name)}`).join(", ");
+		if (used.length > 0) {
+			usesBody = true;
+			from = `json_to_record(($1::text)::json) AS _args(${used.map((a) => `${quoteIdent(a.name)} ${a.type}`).join(", ")}) CROSS JOIN LATERAL `;
+		}
+	}
+	const call = `${from}${fnRef}(${args}) AS _f`;
+	const base = fn.returnsVoid ? `SELECT 1 AS pgrst_scalar FROM ${call}` : fn.returnsComposite ? `SELECT _f.* FROM ${call}` : `SELECT _f AS pgrst_scalar FROM ${call}`;
+	const shape = fn.returnsVoid ? "void" : fn.returnsComposite ? fn.returnsSet ? "rows" : "object" : fn.returnsSet ? "scalar-set" : "scalar";
+	const relation = relationOfReturnType(cache, fn) ?? syntheticRelation(fn);
+	return {
+		fn,
+		shape,
+		source: base,
+		usesBody,
+		relation
+	};
+};
+
+//#endregion
+//#region src/sql/statement.ts
+const CSV_BODY = "coalesce((SELECT string_agg(k, ',') FROM (SELECT json_object_keys(r)::text AS k FROM (SELECT row_to_json(hh) AS r FROM pgrst_body AS hh LIMIT 1) s) a), '') || E'\\n' || coalesce(string_agg(substring(_t::text, 2, length(_t::text) - 2), E'\\n'), '')";
+const handlerBody = (h) => {
+	if (h.aggregate) {
+		const call = `${h.aggregate}(${h.rowType ? `ROW(_t.*)::${h.rowType}` : "_t"})`;
+		return h.bytea ? `coalesce(encode(${call}::bytea, 'hex'), '')` : `coalesce(${call}::text, '')`;
+	}
+	return h.bytea ? `coalesce(encode((array_agg(_t.pgrst_scalar::bytea))[1], 'hex'), '')` : `coalesce((array_agg(_t.pgrst_scalar::text))[1], '')`;
+};
+const GEOJSON_BODY = "json_build_object('type', 'FeatureCollection', 'features', coalesce(json_agg(ST_AsGeoJSON(_t)::json), '[]'::json))::text";
+const bodyExpr = (shape, strip, csv, handler, geojson) => {
+	if (geojson && shape !== "none") return GEOJSON_BODY;
+	if (handler && shape !== "none") return handlerBody(handler);
+	if (csv && shape !== "none") return CSV_BODY;
+	const wrap = (e) => strip ? `json_strip_nulls(${e})` : e;
+	switch (shape) {
+		case "array": return `coalesce(${wrap("json_agg(_t)")}, '[]'::json)::text`;
+		case "object": return `coalesce((${wrap("json_agg(_t)")} -> 0), 'null'::json)::text`;
+		case "scalar-array": return `coalesce(json_agg(_t.pgrst_scalar), '[]'::json)::text`;
+		case "scalar": return `coalesce((json_agg(_t.pgrst_scalar) -> 0)::text, 'null')`;
+		case "none": return `''::text`;
+	}
+};
+/**
+* The one statement that runs a request. Result columns:
+* `page_total`, `body`, `total_result_set`, `response_headers`, `response_status`.
+*
+* `response.headers` / `response.status` are read at the end so that functions
+* (RPC, triggers) can influence the response by calling `set_config`.
+*/
+const buildStatement = (o) => {
+	const up = o.upsertColumns;
+	return `WITH ${[...o.source && up ? [`pgrst_ins AS (${o.source})`, `pgrst_source AS (SELECT ${up.join(", ")} FROM pgrst_ins)`] : o.source ? [`pgrst_source AS (${o.source})`] : [], `pgrst_body AS (${o.rows})`].join(", ")} SELECT count(*)::text AS page_total, ${bodyExpr(o.shape, Boolean(o.stripNulls), Boolean(o.csv), o.handler, o.geojson)} AS body, ${o.count ? `(${o.count})::text` : "NULL::text"} AS total_result_set, nullif(current_setting('response.headers', true), '') AS response_headers, ` + (up ? `coalesce(nullif(current_setting('response.status', true), ''), CASE WHEN EXISTS (SELECT 1 FROM pgrst_ins) AND NOT EXISTS (SELECT 1 FROM pgrst_ins WHERE pgrst_inserted) THEN '200' END)` : `nullif(current_setting('response.status', true), '')`) + " AS response_status FROM pgrst_body AS _t";
+};
+
+//#endregion
+//#region src/sql/write.ts
+const returningSql = (rel, returning) => {
+	const alias = quoteIdent(ROOT_ALIAS);
+	if (returning === "representation") return `${alias}.*`;
+	if (returning === "pk" && rel.pk.length > 0) return rel.pk.map((c) => `${alias}.${quoteIdent(c)}`).join(", ");
+	return "1";
+};
+const columnNotFound = (rel, column) => new PgRestError(400, "PGRST204", `Could not find the '${column}' column of '${rel.name}' in the schema cache`, null, null);
+const checkColumns = (rel, cols) => {
+	const known = new Set(rel.columns.map((c) => c.name));
+	for (const c of cols) if (!known.has(c)) throw columnNotFound(rel, c);
+};
+const unionKeys = (rows) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const r of rows) for (const k of Object.keys(r)) seen.add(k);
+	return [...seen];
+};
+/**
+* `INSERT … RETURNING …`. The payload is `$1` (JSON text, an array of objects);
+* it is always cast through `$1::text` so the driver never re-encodes it.
+*/
+const buildInsert = (o) => {
+	const { rel } = o;
+	const table = quoteQualified(rel.schema, rel.name);
+	const target = `${table} AS ${quoteIdent(ROOT_ALIAS)}`;
+	const returning = returningSql(rel, o.returning);
+	const cols = o.columns ? [...o.columns] : unionKeys(o.rows);
+	if (!o.columns && o.rows.some((r) => Object.keys(r).length !== cols.length)) throw new PgRestError(400, "PGRST102", "All object keys must match");
+	checkColumns(rel, cols);
+	if (o.rows.length === 0) {
+		const first = rel.columns[0];
+		if (!first) throw new PgRestError(400, "PGRST102", "Cannot insert into a relation without columns");
+		return `INSERT INTO ${target} (${quoteIdent(first.name)}) SELECT NULL WHERE FALSE RETURNING ${returning}`;
+	}
+	if (cols.length === 0) {
+		const first = rel.columns[0];
+		if (!first) throw new PgRestError(400, "PGRST102", "Cannot insert into a relation without columns");
+		const values = o.rows.map(() => "(DEFAULT)").join(", ");
+		return `INSERT INTO ${target} (${quoteIdent(first.name)}) VALUES ${values || "(DEFAULT)"} RETURNING ${returning}`;
+	}
+	const colList = cols.map(quoteIdent).join(", ");
+	const typed = `null::${table}`;
+	const json = "($1::text)::json";
+	let select;
+	if (o.missingDefault) {
+		const byName = new Map(rel.columns.map((c) => [c.name, c]));
+		select = `SELECT ${cols.map((c) => {
+			const allPresent = o.rows.every((r) => c in r);
+			const value = `_p.${quoteIdent(c)}`;
+			if (allPresent) return value;
+			const dflt = byName.get(c)?.defaultExpr ?? "NULL";
+			return `CASE WHEN (_e.value::jsonb) ? ${"'" + c.replace(/'/g, "''") + "'"} THEN ${value} ELSE ${dflt} END`;
+		}).join(", ")} FROM json_array_elements(${json}) AS _e(value) CROSS JOIN LATERAL json_populate_record(${typed}, _e.value) AS _p`;
+	} else select = `SELECT ${colList} FROM json_populate_recordset(${typed}, ${json})`;
+	let conflict = "";
+	if (o.resolution) {
+		const keys = o.onConflict && o.onConflict.length > 0 ? o.onConflict : rel.pk;
+		checkColumns(rel, keys);
+		const targetCols = keys.length ? ` (${keys.map(quoteIdent).join(", ")})` : "";
+		if (o.resolution === "ignore-duplicates") conflict = ` ON CONFLICT${targetCols} DO NOTHING`;
+		else {
+			if (keys.length === 0) throw new PgRestError(400, "PGRST100", "Upsert needs a conflict target", `"${rel.name}" has no primary key; pass on_conflict=<columns>`);
+			conflict = ` ON CONFLICT${targetCols} DO UPDATE SET ${cols.map((c) => `${quoteIdent(c)} = EXCLUDED.${quoteIdent(c)}`).join(", ")}`;
+		}
+	} else if (o.onConflict && o.onConflict.length > 0) {}
+	const flag = o.flagInserted && o.resolution === "merge-duplicates" ? `, (${quoteIdent(ROOT_ALIAS)}.xmax = 0) AS pgrst_inserted` : "";
+	return `INSERT INTO ${target} (${colList}) ${select}${conflict} RETURNING ${flag && returning === "1" ? "1 AS pgrst_one" : returning}${flag}`;
+};
+/** Columns of `buildInsert`'s output without the `pgrst_inserted` marker, for a merge-duplicates upsert. */
+const upsertColumns = (rel, returning) => {
+	if (returning === "representation") return rel.columns.map((c) => quoteIdent(c.name));
+	if (returning === "pk" && rel.pk.length > 0) return rel.pk.map(quoteIdent);
+	return ["pgrst_one"];
+};
+/** `UPDATE … SET … RETURNING …`, or `null` when the payload sets no columns. */
+const buildUpdate = (o) => {
+	const { rel } = o;
+	const cols = Object.keys(o.body);
+	checkColumns(rel, cols);
+	if (cols.length === 0) return null;
+	const table = quoteQualified(rel.schema, rel.name);
+	const set = cols.map((c) => `${quoteIdent(c)} = _u.${quoteIdent(c)}`).join(", ");
+	const where = whereSql(o.filters, ROOT_ALIAS, rel);
+	return `UPDATE ${table} AS ${quoteIdent(ROOT_ALIAS)} SET ${set} FROM (SELECT * FROM json_populate_record(null::${table}, ($1::text)::json)) AS _u${where.length ? ` WHERE ${where.join(" AND ")}` : ""} RETURNING ${returningSql(rel, o.returning)}`;
+};
+const buildDelete = (o) => {
+	const where = whereSql(o.filters, ROOT_ALIAS, o.rel);
+	return `DELETE FROM ${quoteQualified(o.rel.schema, o.rel.name)} AS ${quoteIdent(ROOT_ALIAS)}${where.length ? ` WHERE ${where.join(" AND ")}` : ""} RETURNING ${returningSql(o.rel, o.returning)}`;
+};
+
+//#endregion
+//#region src/core.ts
+/** Statement options that depend on the negotiated output format. */
+const formatOptions = (format) => ({
+	csv: format.kind === "csv",
+	geojson: format.kind === "geojson",
+	handler: format.kind === "handler" ? format.choice : void 0
+});
+const JSON_CT = "application/json; charset=utf-8";
+const readSchema = (env, request, method) => {
+	const wanted = (method === "GET" || method === "HEAD" ? request.headers.get("accept-profile") : request.headers.get("content-profile"))?.trim();
+	if (!wanted) return env.config.schemas[0];
+	if (!env.config.schemas.includes(wanted)) throw new PgRestError(406, "PGRST106", `Invalid schema: ${wanted}`, null, `Only the following schemas are exposed: ${env.config.schemas.join(", ")}`);
+	return wanted;
+};
+const parseCookies = (header) => {
+	const out = {};
+	if (!header) return out;
+	for (const part of header.split(";")) {
+		const eq = part.indexOf("=");
+		if (eq < 0) continue;
+		const k = part.slice(0, eq).trim();
+		if (!k) continue;
+		const v = part.slice(eq + 1).trim().replace(/^"|"$/g, "");
+		try {
+			out[k] = decodeURIComponent(v);
+		} catch {
+			out[k] = v;
+		}
+	}
+	return out;
+};
+const applyCtxSql = (env, ctx, role, claims, request, method, pathname, schema, prefer) => {
+	const entries = [["role", role], ["request.jwt.claims", JSON.stringify(claims)]];
+	if (env.config.requestSettings) {
+		const headers = {};
+		request.headers.forEach((v, k) => {
+			headers[k] = v;
+		});
+		entries.push(["request.method", method], ["request.path", pathname], ["request.headers", JSON.stringify(headers)], ["request.cookies", JSON.stringify(parseCookies(request.headers.get("cookie")))]);
+	}
+	const searchPath = [schema, ...env.config.extraSearchPath].map(quoteIdent).join(", ");
+	entries.push(["search_path", searchPath]);
+	if (prefer.timezone) entries.push(["timezone", prefer.timezone]);
+	for (const [k, v] of Object.entries(ctx.settings ?? {})) {
+		if (!/^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z0-9_.]+$/.test(k)) throw new PgRestError(500, "PGRST100", `Invalid setting name "${k}"`, null, "Custom settings need a prefix, e.g. app.tenant_id");
+		entries.push([k, v]);
+	}
+	return {
+		sql: `SELECT ${entries.map(([k], i) => `set_config(${literal(k)}, $${i + 1}::text, true)`).join(", ")}`,
+		params: entries.map(([, v]) => v)
+	};
+};
+/** Parsed `response.headers` GUC: `[{"X-A": "b"}, ...]`. */
+const parseResponseHeaders = (raw) => {
+	if (raw == null || raw === "") return {};
+	const bad = () => new PgRestError(500, "PGRST111", "response.headers guc must be a JSON array composed of objects with a single key and a string value");
+	let parsed;
+	try {
+		parsed = JSON.parse(String(raw));
+	} catch {
+		throw bad();
+	}
+	if (!Array.isArray(parsed)) throw bad();
+	const out = {};
+	for (const h of parsed) {
+		if (!h || typeof h !== "object" || Array.isArray(h)) throw bad();
+		const keys = Object.keys(h);
+		if (keys.length !== 1) throw bad();
+		const v = h[keys[0]];
+		if (typeof v !== "string") throw bad();
+		out[keys[0]] = v;
+	}
+	return out;
+};
+const parseStatusGuc = (raw) => {
+	if (raw == null || raw === "") return void 0;
+	const n = Number(raw);
+	if (!Number.isInteger(n) || n < 100 || n > 599) throw new PgRestError(500, "PGRST112", "response.status guc must be a valid status code");
+	return n;
+};
+const appliedHeader = (p, honoredTx) => {
+	const parts = [];
+	if (honoredTx && p.tx) parts.push(`tx=${p.tx}`);
+	if (p.return) parts.push(`return=${p.return}`);
+	if (p.count) parts.push(`count=${p.count}`);
+	if (p.resolution) parts.push(`resolution=${p.resolution}`);
+	if (p.missing) parts.push(`missing=${p.missing}`);
+	if (p.handling) parts.push(`handling=${p.handling}`);
+	if (p.timezone) parts.push(`timezone=${p.timezone}`);
+	if (p.maxAffected !== void 0 && p.handling === "strict") parts.push(`max-affected=${p.maxAffected}`);
+	return parts.length ? parts.join(", ") : void 0;
+};
+var RollbackWith = class extends Error {
+	constructor(value) {
+		super("rollback");
+		this.value = value;
+	}
+};
+const asRows = (body) => {
+	const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+	if (Array.isArray(body)) {
+		if (!body.every(isObj)) throw new PgRestError(400, "PGRST102", "All object keys must match");
+		return body;
+	}
+	return isObj(body) ? [body] : [];
+};
+const effectivePaging = (env, query, range) => {
+	if (query.root.limit !== void 0 && query.root.limit < 0) throw new PgRestError(416, "PGRST103", "Requested range not satisfiable", "Limit should be greater than or equal to zero.", null);
+	let limit = query.root.limit ?? range?.limit;
+	const offset = query.root.offset ?? range?.offset ?? 0;
+	const max = env.config.maxRows;
+	if (max !== void 0) limit = limit === void 0 ? max : Math.min(limit, max);
+	return {
+		limit,
+		offset
+	};
+};
+const handleRequest = async (env, request, ctx) => {
+	if (!ctx.role && env.config.anonymousRole === void 0) throw new PgRestError(401, "PGRST302", "Anonymous access is disabled", null, null);
+	if (!isSupportedMethod(request.method)) return new Response(null, {
+		status: 405,
+		headers: { "Content-Type": JSON_CT }
+	});
+	const method = parseMethod(request.method);
+	const url = new URL(request.url);
+	const target = parseTarget(url.pathname, env.config.basePath);
+	const schema = readSchema(env, request, method);
+	const prefer = parsePrefer(request.headers.get("prefer"));
+	const invalid = [...prefer.invalid];
+	const honoredTx = env.config.allowTxOverride;
+	if (prefer.tx && !honoredTx) invalid.push(`tx=${prefer.tx}`);
+	if (prefer.handling === "strict" && invalid.length > 0) throw new PgRestError(400, "PGRST122", "Invalid preferences given with handling=strict", `Invalid preferences: ${invalid.join(", ")}`);
+	if (method === "OPTIONS") {
+		const allow = target.type === "root" ? "OPTIONS,GET,HEAD" : target.type === "rpc" ? "OPTIONS,GET,HEAD,POST" : (() => {
+			const rel = getRelation(env.cache, schema, target.name);
+			const m = [
+				"OPTIONS",
+				"GET",
+				"HEAD"
+			];
+			if (rel.insertable) m.push("POST");
+			if (rel.insertable && rel.updatable) m.push("PUT");
+			if (rel.updatable) m.push("PATCH");
+			if (rel.deletable) m.push("DELETE");
+			return m.join(",");
+		})();
+		return new Response(null, {
+			status: 200,
+			headers: { Allow: allow }
+		});
+	}
+	if (target.type === "root") {
+		if (method !== "GET" && method !== "HEAD") throw new PgRestError(405, "PGRST117", `Unsupported HTTP method: ${method}`);
+		if (!env.config.openApi) throw new PgRestError(404, "PGRST126", "Root endpoint metadata is disabled");
+		parseAccept(request.headers.get("accept"), true);
+		const doc = buildOpenApi(env.cache, schema, {
+			serverUrl: env.config.serverUrl ?? url.origin,
+			basePath: env.config.basePath
+		});
+		return new Response(method === "HEAD" ? null : JSON.stringify(doc), {
+			status: 200,
+			headers: { "Content-Type": "application/openapi+json; charset=utf-8" }
+		});
+	}
+	const requested = parseAccept(request.headers.get("accept"), false, env.config.planEnabled, mediaChoices(env.cache, schema, target, url.searchParams.has("select")));
+	const format = requested.kind === "plan" ? requested.inner : requested;
+	const wantsPlan = requested.kind === "plan" ? requested : void 0;
+	const range = parseRange(request.headers.get("range"), request.headers.get("range-unit"));
+	const body = await parseBody(request, method);
+	let plan;
+	if (target.type === "table") plan = planTable(env, method, schema, target.name, url, prefer, format, range, body);
+	else plan = planRpc(env, method, schema, target.name, url, prefer, format, range, body);
+	return execute(env, ctx, request, method, url.pathname, schema, prefer, format, plan, honoredTx, wantsPlan);
+};
+const planTable = (env, method, schema, name, url, prefer, format, range, body) => {
+	const rel = getRelation(env.cache, schema, name);
+	const query = parseQuery([...url.searchParams]);
+	const strip = format.kind === "json" || format.kind === "object" ? format.stripNulls : false;
+	const singular = format.kind === "object";
+	if (method === "GET" || method === "HEAD") {
+		const { limit, offset } = effectivePaging(env, query, range);
+		const read = buildRead({
+			cache: env.cache,
+			rel,
+			from: `${quoteIdent(rel.schema)}.${quoteIdent(rel.name)}`,
+			query,
+			limit,
+			offset
+		});
+		const shape$1 = singular ? "object" : "array";
+		const paged = limit !== void 0 || offset > 0;
+		const needCount = prefer.count === "exact" || prefer.count === "estimated";
+		return {
+			method,
+			kind: "read",
+			readOnly: true,
+			source: false,
+			params: [],
+			shape: shape$1,
+			rel,
+			offset,
+			limit,
+			pagedRead: paged,
+			countInStatement: needCount && paged,
+			planned: prefer.count === "planned" || prefer.count === "estimated" ? read.unpaged : void 0,
+			statement: buildStatement({
+				rows: read.rows,
+				count: needCount && paged ? read.count : void 0,
+				shape: shape$1,
+				stripNulls: strip,
+				...formatOptions(format)
+			})
+		};
+	}
+	const returning = prefer.return === "representation" ? "representation" : prefer.return === "headers-only" ? "pk" : "minimal";
+	const shapeFor = (r) => r === "representation" ? singular ? "object" : "array" : r === "pk" ? "array" : "none";
+	const rowsFor = (r) => {
+		if (r === "representation") {
+			const resultQuery = {
+				...query,
+				root: {
+					...query.root,
+					filters: [],
+					presence: []
+				}
+			};
+			return {
+				rows: buildRead({
+					cache: env.cache,
+					rel,
+					from: "pgrst_source",
+					query: resultQuery
+				}).rows,
+				shape: shapeFor(r)
+			};
+		}
+		return {
+			rows: "SELECT * FROM pgrst_source",
+			shape: shapeFor(r)
+		};
+	};
+	const common = {
+		method,
+		rel,
+		readOnly: false,
+		source: true,
+		offset: 0,
+		countInStatement: false,
+		pagedRead: false
+	};
+	if (method === "POST") {
+		if (!body) throw new PgRestError(400, "PGRST102", "Empty or invalid json");
+		const rows = asRows(body.value);
+		const insertSql = buildInsert({
+			rel,
+			rows,
+			columns: query.columns,
+			onConflict: query.onConflict,
+			resolution: prefer.resolution,
+			missingDefault: prefer.missing === "default",
+			flagInserted: true,
+			returning
+		});
+		const { rows: outRows$1, shape: shape$1 } = rowsFor(returning);
+		return {
+			...common,
+			kind: "insert",
+			returning,
+			params: insertSql.includes("$1") ? [JSON.stringify(rows)] : [],
+			shape: shape$1,
+			statement: buildStatement({
+				source: insertSql,
+				rows: outRows$1,
+				shape: shape$1,
+				stripNulls: strip,
+				...formatOptions(format),
+				upsertColumns: insertSql.includes("pgrst_inserted") ? upsertColumns(rel, returning) : void 0
+			})
+		};
+	}
+	if (method === "PATCH") {
+		if (!body) throw new PgRestError(400, "PGRST102", "Empty or invalid json");
+		const first = Array.isArray(body.value) ? body.value[0] : body.value;
+		const obj$1 = first !== null && typeof first === "object" && !Array.isArray(first) ? first : {};
+		const updateSql = buildUpdate({
+			rel,
+			body: obj$1,
+			filters: query.root.filters,
+			returning
+		});
+		const { rows: outRows$1, shape: shape$1 } = rowsFor(returning);
+		if (updateSql === null) {
+			const emptyShape = returning === "representation" ? singular ? "object" : "array" : "none";
+			return {
+				...common,
+				kind: "update",
+				returning,
+				params: [],
+				shape: emptyShape,
+				statement: buildStatement({
+					source: "SELECT 1 WHERE FALSE",
+					rows: "SELECT * FROM pgrst_source",
+					shape: emptyShape,
+					...formatOptions(format)
+				})
+			};
+		}
+		return {
+			...common,
+			kind: "update",
+			returning,
+			params: [JSON.stringify(obj$1)],
+			shape: shape$1,
+			statement: buildStatement({
+				source: updateSql,
+				rows: outRows$1,
+				shape: shape$1,
+				stripNulls: strip,
+				...formatOptions(format)
+			})
+		};
+	}
+	if (method === "DELETE") {
+		const deleteSql = buildDelete({
+			rel,
+			filters: query.root.filters,
+			returning
+		});
+		const { rows: outRows$1, shape: shape$1 } = rowsFor(returning);
+		return {
+			...common,
+			kind: "delete",
+			returning,
+			params: [],
+			shape: shape$1,
+			statement: buildStatement({
+				source: deleteSql,
+				rows: outRows$1,
+				shape: shape$1,
+				stripNulls: strip,
+				...formatOptions(format)
+			})
+		};
+	}
+	if (!body) throw new PgRestError(400, "PGRST102", "Empty or invalid json");
+	const row = body.value;
+	if (Array.isArray(row) && !row.every((r) => r !== null && typeof r === "object" && !Array.isArray(r))) throw new PgRestError(400, "PGRST102", "All object keys must match");
+	if (row === null || typeof row !== "object" || Array.isArray(row)) throw new PgRestError(400, "PGRST102", "Empty or invalid json", "The payload of a PUT request must be a JSON object");
+	if (query.root.limit !== void 0 || query.root.offset !== void 0) throw new PgRestError(400, "PGRST114", "limit/offset querystring parameters are not allowed for PUT");
+	if (rel.pk.length === 0) throw new PgRestError(405, "PGRST105", "Filters must include all and only primary key columns with 'eq' operators");
+	const keyValues = /* @__PURE__ */ new Map();
+	for (const f of query.root.filters) if (f.kind === "filter" && f.op === "eq" && !f.negate && !f.quantifier && f.field.json.length === 0 && typeof f.value === "string" && rel.pk.includes(f.field.name)) keyValues.set(f.field.name, f.value);
+	else throw new PgRestError(405, "PGRST105", "Filters must include all and only primary key columns with 'eq' operators");
+	if (!rel.pk.every((c) => keyValues.has(c))) throw new PgRestError(405, "PGRST105", "Filters must include all and only primary key columns with 'eq' operators");
+	const obj = row;
+	for (const c of rel.pk) if (c in obj && String(obj[c]) !== keyValues.get(c)) throw new PgRestError(400, "PGRST115", "Payload values do not match URL in primary key column(s)");
+	const full = {
+		...Object.fromEntries(rel.pk.map((c) => [c, keyValues.get(c)])),
+		...obj
+	};
+	const putSql = buildInsert({
+		rel,
+		rows: [full],
+		onConflict: rel.pk,
+		resolution: "merge-duplicates",
+		returning
+	});
+	const { rows: outRows, shape } = rowsFor(returning);
+	return {
+		...common,
+		kind: "put",
+		returning,
+		params: [JSON.stringify([full])],
+		shape,
+		statement: buildStatement({
+			source: putSql,
+			rows: outRows,
+			shape,
+			stripNulls: strip,
+			...formatOptions(format)
+		})
+	};
+};
+/** A query-string value in the filter syntax (`eq.5`, `not.in.(1,2)`, `like(any).{a*}`), not a plain argument. */
+const looksLikeFilter = (v) => /^(not\.)?(eq|neq|gt|gte|lt|lte|like|ilike|match|imatch|in|is|isdistinct|cs|cd|ov|sl|sr|nxl|nxr|adj|fts|plfts|phfts|wfts)(\([a-z]+\))?\./.test(v);
+const planRpc = (env, method, schema, name, url, prefer, format, range, body) => {
+	if (method !== "GET" && method !== "HEAD" && method !== "POST") throw new PgRestError(405, "PGRST101", `Cannot use the ${method} method on RPC`);
+	const RESERVED = new Set([
+		"select",
+		"order",
+		"limit",
+		"offset",
+		"and",
+		"or",
+		"columns",
+		"on_conflict"
+	]);
+	let argValues = {};
+	let nonObjectBody = false;
+	const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+	const getArgKeys = /* @__PURE__ */ new Set();
+	const bare = /* @__PURE__ */ new Set();
+	if (method === "POST") {
+		if (body) {
+			const v = body.value;
+			if (isObj(v)) argValues = v;
+			else {
+				nonObjectBody = true;
+				if (Array.isArray(v) && v.length > 0) {
+					const keysOf = (o) => isObj(o) ? Object.keys(o).sort().join("\0") : void 0;
+					const first = keysOf(v[0]);
+					if (first === void 0 || v.some((o) => keysOf(o) !== first)) throw new PgRestError(400, "PGRST102", "All object keys must match", null, null);
+					argValues = v[0];
+				}
+			}
+		}
+	} else {
+		for (const kv of url.search.slice(1).split("&")) if (kv !== "" && !kv.includes("=")) bare.add(decodeURIComponent(kv));
+		const lists = /* @__PURE__ */ new Map();
+		for (const [k, v] of url.searchParams) {
+			if (RESERVED.has(k) || bare.has(k) || looksLikeFilter(v) || k.includes(".")) continue;
+			lists.set(k, [...lists.get(k) ?? [], v]);
+		}
+		for (const [k, vs] of lists) {
+			getArgKeys.add(k);
+			argValues[k] = vs.length === 1 ? vs[0] : vs;
+		}
+	}
+	const provided = Object.keys(argValues);
+	const fn = resolveFunction(env.cache, schema, name, new Set(provided), nonObjectBody, method === "POST");
+	for (const a of fn.args) if (a.variadic && getArgKeys.has(a.name) && !Array.isArray(argValues[a.name])) argValues[a.name] = [argValues[a.name]];
+	const rawBody = nonObjectBody && isSingleUnnamedParam(fn);
+	const call = buildRpc(env.cache, fn, provided, rawBody);
+	const fnArgNames = new Set(fn.args.map((a) => a.name));
+	const query = parseQuery([...url.searchParams].filter(([k, v]) => !(v === "" && bare.has(k))), { allowFilterKey: (k) => method === "POST" || !fnArgNames.has(k) });
+	const argsJson = rawBody ? JSON.stringify(body.value) : JSON.stringify(argValues);
+	const params = call.usesBody ? [rawBody && body.kind === "json" && typeof body.value === "string" ? body.value : argsJson] : [];
+	const strip = format.kind === "json" || format.kind === "object" ? format.stripNulls : false;
+	const base = {
+		method,
+		kind: "rpc",
+		readOnly: method !== "POST",
+		source: false,
+		rpc: call,
+		rel: call.relation,
+		params,
+		offset: 0,
+		countInStatement: false,
+		pagedRead: false
+	};
+	if (call.shape === "rows" || call.shape === "object") {
+		const { limit, offset } = effectivePaging(env, query, range);
+		const read = buildRead({
+			cache: env.cache,
+			rel: call.relation,
+			from: `(${call.source})`,
+			query,
+			limit,
+			offset
+		});
+		const shape$1 = call.shape === "object" || format.kind === "object" ? "object" : "array";
+		const paged = limit !== void 0 || offset > 0;
+		const needCount = prefer.count === "exact" || prefer.count === "estimated";
+		return {
+			...base,
+			offset,
+			limit,
+			pagedRead: paged,
+			countInStatement: needCount && paged,
+			planned: prefer.count === "planned" || prefer.count === "estimated" ? read.unpaged : void 0,
+			shape: shape$1,
+			statement: buildStatement({
+				rows: read.rows,
+				count: needCount && paged ? read.count : void 0,
+				shape: shape$1,
+				stripNulls: strip,
+				...formatOptions(format)
+			})
+		};
+	}
+	const shape = call.shape === "void" && format.kind !== "geojson" ? "none" : call.shape === "scalar" ? "scalar" : "scalar-array";
+	return {
+		...base,
+		shape,
+		statement: buildStatement({
+			rows: call.source,
+			shape,
+			...formatOptions(format)
+		})
+	};
+};
+const execute = async (env, ctx, request, method, pathname, schema, prefer, format, plan, honoredTx, wantsPlan) => {
+	const role = ctx.role ?? env.config.anonymousRole;
+	const claims = {
+		role,
+		...ctx.claims ?? {}
+	};
+	const setup = applyCtxSql(env, ctx, role, claims, request, method, pathname, schema, prefer);
+	const strict = prefer.handling === "strict";
+	const rollback = honoredTx && prefer.tx === "rollback" || wantsPlan !== void 0;
+	const attempt = async () => {
+		try {
+			return await env.db.transaction(async (s) => {
+				if (plan.readOnly) await s.query("SET TRANSACTION READ ONLY");
+				await s.query(setup.sql, setup.params);
+				const pre = env.config.preRequest;
+				if (typeof pre === "string") await s.query(`SELECT ${pre.split(".").map(quoteIdent).join(".")}()`);
+				else if (pre) await pre(s, {
+					role,
+					claims,
+					method,
+					path: pathname,
+					request
+				});
+				let planned;
+				if (plan.planned) {
+					const cell = (await s.query(`EXPLAIN (FORMAT JSON) ${plan.planned}`))[0]?.["QUERY PLAN"];
+					const parsed = typeof cell === "string" ? JSON.parse(cell) : cell;
+					const n = Number(parsed?.[0]?.Plan?.["Plan Rows"]);
+					planned = Number.isFinite(n) ? n : void 0;
+				}
+				if (wantsPlan) {
+					const opts = ["FORMAT " + wantsPlan.format.toUpperCase(), ...wantsPlan.options.map((o) => o.toUpperCase())];
+					const cells = (await s.query(`EXPLAIN (${opts.join(", ")}) ${plan.statement}`, plan.params)).map((l) => l["QUERY PLAN"]);
+					throw new RollbackWith({
+						pageTotal: 0,
+						body: wantsPlan.format === "json" ? typeof cells[0] === "string" ? cells[0] : JSON.stringify(cells[0], null, 2) : cells.join("\n"),
+						total: void 0,
+						planned: void 0,
+						responseHeaders: {},
+						responseStatus: void 0
+					});
+				}
+				const row = (await s.query(plan.statement, plan.params))[0] ?? {};
+				const pageTotal = Number(row["page_total"] ?? 0);
+				const raw = {
+					pageTotal,
+					body: String(row["body"] ?? ""),
+					total: row["total_result_set"] == null ? void 0 : Number(row["total_result_set"]),
+					planned,
+					responseHeaders: parseResponseHeaders(row["response_headers"]),
+					responseStatus: parseStatusGuc(row["response_status"])
+				};
+				if (format.kind === "object" && plan.shape === "object" && plan.rpc?.shape !== "object" && pageTotal !== 1) throw new PgRestError(406, "PGRST116", "Cannot coerce the result to a single JSON object", `The result contains ${pageTotal} rows`);
+				if (strict && prefer.maxAffected !== void 0) {
+					if (plan.kind === "rpc" && plan.rpc && !plan.rpc.fn.returnsSet) throw new PgRestError(400, "PGRST128", "max-affected preference is only valid for functions that return a set", null, null);
+					if ((plan.kind === "update" || plan.kind === "delete" || plan.kind === "rpc") && pageTotal > prefer.maxAffected) throw new PgRestError(400, "PGRST124", "Query result exceeds max-affected preference constraint", `The query affects ${pageTotal} rows`);
+				}
+				if (rollback) throw new RollbackWith(raw);
+				return raw;
+			});
+		} catch (e) {
+			if (e instanceof RollbackWith) return e.value;
+			if (e instanceof DbQueryError && plan.kind !== "rpc" && plan.rel) {
+				const fix = (t) => t?.replace(/"pgrst_root"/g, `"${plan.rel.name}"`).replace(/pgrst_root\./g, `${plan.rel.name}.`);
+				throw new DbQueryError(e.sqlState, fix(e.message) ?? e.message, fix(e.detail), fix(e.hint));
+			}
+			throw e;
+		}
+	};
+	let result;
+	for (let i = 0;; i++) try {
+		result = await attempt();
+		break;
+	} catch (e) {
+		if (e instanceof DbQueryError && e.sqlState === "40001" && i < 2) continue;
+		throw e;
+	}
+	if (wantsPlan) {
+		const opts = wantsPlan.options.length ? `; options=${wantsPlan.options.join("|")}` : "";
+		return new Response(method === "HEAD" ? null : result.body, {
+			status: 200,
+			headers: {
+				"Content-Type": `application/vnd.pgrst.plan+${wantsPlan.format}; for="${wantsPlan.forType}"${opts}; charset=utf-8`,
+				Vary: "Accept, Prefer, Range"
+			}
+		});
+	}
+	return buildResponse(env, request, method, prefer, format, plan, result, honoredTx);
+};
+const buildResponse = (env, request, method, prefer, format, plan, r, honoredTx) => {
+	const headers = { Vary: "Accept, Prefer, Range" };
+	const applied = appliedHeader(prefer, honoredTx);
+	if (applied) headers["Preference-Applied"] = applied;
+	let total;
+	if (prefer.count === "exact") total = plan.countInStatement ? r.total : r.pageTotal;
+	else if (prefer.count === "planned") total = r.planned;
+	else if (prefer.count === "estimated") {
+		const max = env.config.maxRows;
+		total = max !== void 0 && r.planned !== void 0 && r.planned > max ? r.planned : plan.countInStatement ? r.total : r.pageTotal;
+	}
+	const totalStr = total === void 0 ? "*" : String(total);
+	let status = 200;
+	let text = r.body;
+	let contentType = JSON_CT;
+	if (plan.kind === "read" || plan.kind === "rpc" && plan.pagedRead !== void 0 && (plan.shape === "array" || plan.shape === "object")) {
+		const first = plan.offset;
+		const last = plan.offset + r.pageTotal - 1;
+		headers["Content-Range"] = r.pageTotal > 0 ? `${first}-${last}/${totalStr}` : `*/${totalStr}`;
+		if (total !== void 0 && plan.offset > 0 && r.pageTotal === 0 && plan.offset >= total && prefer.count !== "planned") throw new PgRestError(416, "PGRST103", "Requested range not satisfiable", `An offset of ${plan.offset} was requested, but there are only ${total} rows.`, null, {
+			"Content-Range": `*/${total}`,
+			...applied ? { "Preference-Applied": applied } : {}
+		});
+		if (total !== void 0 && r.pageTotal > 0 && r.pageTotal < total) status = 206;
+		if (total !== void 0 && r.pageTotal === total && plan.offset > 0) status = 206;
+	} else if (plan.kind === "rpc") {
+		status = plan.shape === "none" ? 204 : 200;
+		headers["Content-Range"] = r.pageTotal > 0 ? `0-${r.pageTotal - 1}/${totalStr}` : `*/${totalStr}`;
+	} else {
+		if (plan.kind === "update") {
+			const n = r.pageTotal;
+			headers["Content-Range"] = n > 0 ? `0-${n - 1}/${prefer.count === "exact" ? String(n) : "*"}` : `*/${prefer.count === "exact" ? "0" : "*"}`;
+		} else if (plan.kind !== "put") headers["Content-Range"] = `*/${prefer.count === "exact" ? String(r.pageTotal) : "*"}`;
+		const ret = plan.returning ?? "minimal";
+		if (plan.kind === "insert") {
+			status = 201;
+			if (ret === "pk") {
+				const rows = JSON.parse(r.body || "[]");
+				const pk = plan.rel?.pk ?? [];
+				if (rows.length === 1 && pk.length > 0) {
+					const q = pk.map((c) => `${encodeURIComponent(c)}=eq.${encodeURIComponent(String(rows[0][c]))}`).join("&");
+					headers["Location"] = `/${encodeURIComponent(plan.rel.name)}?${q}`;
+				}
+			}
+		} else if (plan.kind === "put") status = ret === "representation" ? 200 : 204;
+		else status = ret === "representation" ? 200 : 204;
+		if (ret !== "representation") text = "";
+		else if (plan.shape === "none") text = "";
+	}
+	if (plan.kind === "insert" && (plan.returning ?? "minimal") !== "representation") text = "";
+	if (format.kind === "handler") contentType = format.choice.contentType;
+	else if (format.kind === "csv") contentType = "text/csv; charset=utf-8";
+	else if (format.kind === "geojson") contentType = "application/geo+json; charset=utf-8";
+	else if (format.kind === "object") contentType = `application/vnd.pgrst.object+json${format.stripNulls ? ";nulls=stripped" : ""}; charset=utf-8`;
+	else if (format.kind === "json" && format.stripNulls) contentType = "application/vnd.pgrst.array+json;nulls=stripped; charset=utf-8";
+	Object.assign(headers, r.responseHeaders);
+	if (r.responseStatus !== void 0) status = r.responseStatus;
+	const noBody = status === 204 || status === 304 || text === "" || method === "HEAD";
+	if (!(status === 204 || status === 304 || text === "" && method !== "HEAD" && !(format.kind === "handler" && plan.kind === "read"))) headers["Content-Type"] = contentType;
+	if (!noBody && format.kind === "handler" && format.choice.bytea) return new Response(Buffer.from(text, "hex"), {
+		status,
+		headers
+	});
+	return new Response(noBody ? null : text, {
+		status,
+		headers
+	});
+};
+
+//#endregion
+//#region src/service.ts
+/** The schema could not be read from the database catalog. */
+var SchemaLoadError = class extends Error {
+	_tag = "SchemaLoadError";
+	constructor(cause) {
+		super(`pg-rest: could not load the database schema: ${cause instanceof Error ? cause.message : String(cause)}`);
+		this.cause = cause;
+		this.name = "SchemaLoadError";
+	}
+};
+const createSchemaStore = async (db, schemas) => {
+	const load = () => introspect(db, schemas).catch((cause) => {
+		throw new SchemaLoadError(cause);
+	});
+	let cache = await load();
+	let queue = Promise.resolve();
+	return {
+		current: () => cache,
+		reload() {
+			const run$2 = queue.then(async () => {
+				try {
+					cache = await load();
+					return cache;
+				} catch (e) {
+					console.warn("pg-rest: schema cache reload failed, keeping the previous cache", e.cause);
+					throw e;
+				}
+			});
+			queue = run$2.catch(() => void 0);
+			return run$2;
+		}
+	};
+};
+const CONNECTION_ERROR = /^(ERR_POSTGRES_(CONNECTION|AUTH|TLS|IDLE|LIFETIME)|ECONN|ETIMEDOUT|EPIPE|ENOTFOUND)/;
+/** Map anything thrown while handling a request to an {@link ApiError}. */
+const toApiError = (e, role, anonymousRole) => {
+	if (e instanceof ApiError) return e;
+	if (e instanceof PgRestError) return new ApiError({
+		status: e.status,
+		body: e.body,
+		headers: e.headers
+	});
+	if (e instanceof DbQueryError) return dbErrorToApiError(e, role, anonymousRole);
+	const code = e?.code;
+	if (typeof code === "string" && CONNECTION_ERROR.test(code)) return new ApiError({
+		status: 503,
+		headers: {},
+		body: {
+			code: "PGRST001",
+			message: "Database connection failed",
+			details: e instanceof Error ? e.message : null,
+			hint: null
+		}
+	});
+	return new ApiError({
+		status: 500,
+		headers: {},
+		body: {
+			code: "PGRSTX00",
+			message: "Internal error",
+			details: null,
+			hint: null
+		}
+	});
+};
+const errorResponse = (err) => new Response(JSON.stringify(err.body), {
+	status: err.status,
+	headers: {
+		"Content-Type": "application/json; charset=utf-8",
+		...err.status === 401 ? { "WWW-Authenticate": "Bearer" } : {},
+		...err.headers
+	}
+});
+/** Handle a request. Never rejects: errors become PostgREST-style JSON responses. */
+const handleSafely = async (env, request, ctx) => {
+	try {
+		return await handleRequest(env, request, ctx);
+	} catch (e) {
+		const api = toApiError(e, ctx.role ?? env.config.anonymousRole, env.config.anonymousRole);
+		if (api.status >= 500 && !(e instanceof PgRestError) && !(e instanceof DbQueryError)) console.error("pg-rest: unexpected error while handling a request", e);
+		return errorResponse(api);
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const UNEXPOSABLE = new Set(["pg_catalog", "information_schema"]);
+/** Create a PostgREST-compatible handler over a Postgres database. */
+const createPgRest = async (options) => {
+	const schemas = options.schemas?.length ? [...options.schemas] : ["public"];
+	for (const s of schemas) if (UNEXPOSABLE.has(s)) throw new Error(`pg-rest: the schema "${s}" cannot be exposed`);
+	const user = options.db;
+	const adapter = {
+		async query(text, params) {
+			try {
+				return await user.query(text, params);
+			} catch (e) {
+				throw normalizeDbError(e);
+			}
+		},
+		async transaction(fn) {
+			try {
+				return await user.transaction(fn);
+			} catch (e) {
+				throw normalizeDbError(e);
+			}
+		}
+	};
+	const config = {
+		schemas,
+		anonymousRole: options.anonymousRole === false ? void 0 : options.anonymousRole ?? "anon",
+		maxRows: options.maxRows,
+		basePath: options.basePath ?? "",
+		extraSearchPath: options.extraSearchPath ?? ["public"],
+		allowTxOverride: options.allowTxOverride ?? false,
+		planEnabled: options.planEnabled ?? false,
+		openApi: options.openApi ?? true,
+		requestSettings: options.requestSettings ?? true,
+		preRequest: options.preRequest,
+		serverUrl: options.serverUrl
+	};
+	const store = await createSchemaStore(adapter, schemas);
+	const handle = async (request, ctx) => {
+		let context = ctx;
+		if (!context && options.resolveContext) try {
+			context = await options.resolveContext(request);
+		} catch (e) {
+			return errorResponse(e instanceof ApiError ? e : toApiError(e, config.anonymousRole, config.anonymousRole));
+		}
+		return handleSafely({
+			db: adapter,
+			config,
+			cache: store.current()
+		}, request, context ?? {});
+	};
+	return {
+		handle,
+		reloadSchema: async () => void await store.reload(),
+		schemaCache: async () => store.current(),
+		close: async () => {}
+	};
+};
+
+//#endregion
+export { ApiError, DbQueryError, PgRestError, SchemaLoadError, createPgRest };