@rebasepro/server-postgres 0.10.0 → 0.10.1-canary.14e53ae

package/dist/src-DmsRg8MR.js

@@ -0,0 +1,4056 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+import { r as __require, t as __commonJSMin } from "./chunk-DSJWtz9O.js";
+import { c as getDeclaredSubcollections, d as REST_TO_CANONICAL, f as toCanonicalOp, l as isPostgresCollectionConfig, n as getDataSourceCapabilities, o as ANONYMOUS_USER_ID, p as EntityRelation, s as policy, u as NULL_OPS } from "./src-B0v4IKaI.js";
+//#region ../common/src/util/common.ts
+var DEFAULT_ONE_OF_TYPE = "type";
+var DEFAULT_ONE_OF_VALUE = "value";
+var snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]|\b)|[A-Z]?[a-z]+|[0-9]+(?:[a-z](?![a-z]))?|[A-Z]/g;
+var toSnakeCase = (str) => {
+	if (!str || typeof str !== "string") return "";
+	const regExpMatchArray = str.match(snakeCaseRegex);
+	if (!regExpMatchArray) return "";
+	return regExpMatchArray.map((x) => x.toLowerCase()).join("_");
+};
+function camelCase(str) {
+	if (!str) return "";
+	if (str.length === 1) return str.toLowerCase();
+	const parts = str.split(/[-_ ]+/).filter(Boolean);
+	if (parts.length === 0) return "";
+	return parts[0].toLowerCase() + parts.slice(1).map((part) => part.charAt(0).toUpperCase() + part.substring(1).toLowerCase()).join("");
+}
+(/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(e) {
+		var t;
+		"object" == typeof exports ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : ("undefined" != typeof window ? t = window : "undefined" != typeof global ? t = global : "undefined" != typeof self && (t = self), t.objectHash = e());
+	})(function() {
+		return function r(o, i, u) {
+			function s(n, e) {
+				if (!i[n]) {
+					if (!o[n]) {
+						var t = "function" == typeof __require && __require;
+						if (!e && t) return t(n, !0);
+						if (a) return a(n, !0);
+						throw new Error("Cannot find module '" + n + "'");
+					}
+					e = i[n] = { exports: {} };
+					o[n][0].call(e.exports, function(e) {
+						var t = o[n][1][e];
+						return s(t || e);
+					}, e, e.exports, r, o, i, u);
+				}
+				return i[n].exports;
+			}
+			for (var a = "function" == typeof __require && __require, e = 0; e < u.length; e++) s(u[e]);
+			return s;
+		}({
+			1: [function(w, b, m) {
+				(function(e, n, s, c, d, h, p, g, y) {
+					"use strict";
+					var r = w("crypto");
+					function t(e, t) {
+						t = u(e, t);
+						var n;
+						return void 0 === (n = "passthrough" !== t.algorithm ? r.createHash(t.algorithm) : new l()).write && (n.write = n.update, n.end = n.update), f(t, n).dispatch(e), n.update || n.end(""), n.digest ? n.digest("buffer" === t.encoding ? void 0 : t.encoding) : (e = n.read(), "buffer" !== t.encoding ? e.toString(t.encoding) : e);
+					}
+					(m = b.exports = t).sha1 = function(e) {
+						return t(e);
+					}, m.keys = function(e) {
+						return t(e, {
+							excludeValues: !0,
+							algorithm: "sha1",
+							encoding: "hex"
+						});
+					}, m.MD5 = function(e) {
+						return t(e, {
+							algorithm: "md5",
+							encoding: "hex"
+						});
+					}, m.keysMD5 = function(e) {
+						return t(e, {
+							algorithm: "md5",
+							encoding: "hex",
+							excludeValues: !0
+						});
+					};
+					var o = r.getHashes ? r.getHashes().slice() : ["sha1", "md5"], i = (o.push("passthrough"), [
+						"buffer",
+						"hex",
+						"binary",
+						"base64"
+					]);
+					function u(e, t) {
+						var n = {};
+						if (n.algorithm = (t = t || {}).algorithm || "sha1", n.encoding = t.encoding || "hex", n.excludeValues = !!t.excludeValues, n.algorithm = n.algorithm.toLowerCase(), n.encoding = n.encoding.toLowerCase(), n.ignoreUnknown = !0 === t.ignoreUnknown, n.respectType = !1 !== t.respectType, n.respectFunctionNames = !1 !== t.respectFunctionNames, n.respectFunctionProperties = !1 !== t.respectFunctionProperties, n.unorderedArrays = !0 === t.unorderedArrays, n.unorderedSets = !1 !== t.unorderedSets, n.unorderedObjects = !1 !== t.unorderedObjects, n.replacer = t.replacer || void 0, n.excludeKeys = t.excludeKeys || void 0, void 0 === e) throw new Error("Object argument required.");
+						for (var r = 0; r < o.length; ++r) o[r].toLowerCase() === n.algorithm.toLowerCase() && (n.algorithm = o[r]);
+						if (-1 === o.indexOf(n.algorithm)) throw new Error("Algorithm \"" + n.algorithm + "\"  not supported. supported values: " + o.join(", "));
+						if (-1 === i.indexOf(n.encoding) && "passthrough" !== n.algorithm) throw new Error("Encoding \"" + n.encoding + "\"  not supported. supported values: " + i.join(", "));
+						return n;
+					}
+					function a(e) {
+						if ("function" == typeof e) return null != /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i.exec(Function.prototype.toString.call(e));
+					}
+					function f(o, t, i) {
+						i = i || [];
+						function u(e) {
+							return t.update ? t.update(e, "utf8") : t.write(e, "utf8");
+						}
+						return {
+							dispatch: function(e) {
+								return this["_" + (null === (e = o.replacer ? o.replacer(e) : e) ? "null" : typeof e)](e);
+							},
+							_object: function(t) {
+								var n, e = Object.prototype.toString.call(t), r = /\[object (.*)\]/i.exec(e);
+								r = (r = r ? r[1] : "unknown:[" + e + "]").toLowerCase();
+								if (0 <= (e = i.indexOf(t))) return this.dispatch("[CIRCULAR:" + e + "]");
+								if (i.push(t), void 0 !== s && s.isBuffer && s.isBuffer(t)) return u("buffer:"), u(t);
+								if ("object" === r || "function" === r || "asyncfunction" === r) return e = Object.keys(t), o.unorderedObjects && (e = e.sort()), !1 === o.respectType || a(t) || e.splice(0, 0, "prototype", "__proto__", "constructor"), o.excludeKeys && (e = e.filter(function(e) {
+									return !o.excludeKeys(e);
+								})), u("object:" + e.length + ":"), n = this, e.forEach(function(e) {
+									n.dispatch(e), u(":"), o.excludeValues || n.dispatch(t[e]), u(",");
+								});
+								if (!this["_" + r]) {
+									if (o.ignoreUnknown) return u("[" + r + "]");
+									throw new Error("Unknown object type \"" + r + "\"");
+								}
+								this["_" + r](t);
+							},
+							_array: function(e, t) {
+								t = void 0 !== t ? t : !1 !== o.unorderedArrays;
+								var n = this;
+								if (u("array:" + e.length + ":"), !t || e.length <= 1) return e.forEach(function(e) {
+									return n.dispatch(e);
+								});
+								var r = [], t = e.map(function(e) {
+									var t = new l(), n = i.slice();
+									return f(o, t, n).dispatch(e), r = r.concat(n.slice(i.length)), t.read().toString();
+								});
+								return i = i.concat(r), t.sort(), this._array(t, !1);
+							},
+							_date: function(e) {
+								return u("date:" + e.toJSON());
+							},
+							_symbol: function(e) {
+								return u("symbol:" + e.toString());
+							},
+							_error: function(e) {
+								return u("error:" + e.toString());
+							},
+							_boolean: function(e) {
+								return u("bool:" + e.toString());
+							},
+							_string: function(e) {
+								u("string:" + e.length + ":"), u(e.toString());
+							},
+							_function: function(e) {
+								u("fn:"), a(e) ? this.dispatch("[native]") : this.dispatch(e.toString()), !1 !== o.respectFunctionNames && this.dispatch("function-name:" + String(e.name)), o.respectFunctionProperties && this._object(e);
+							},
+							_number: function(e) {
+								return u("number:" + e.toString());
+							},
+							_xml: function(e) {
+								return u("xml:" + e.toString());
+							},
+							_null: function() {
+								return u("Null");
+							},
+							_undefined: function() {
+								return u("Undefined");
+							},
+							_regexp: function(e) {
+								return u("regex:" + e.toString());
+							},
+							_uint8array: function(e) {
+								return u("uint8array:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_uint8clampedarray: function(e) {
+								return u("uint8clampedarray:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_int8array: function(e) {
+								return u("int8array:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_uint16array: function(e) {
+								return u("uint16array:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_int16array: function(e) {
+								return u("int16array:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_uint32array: function(e) {
+								return u("uint32array:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_int32array: function(e) {
+								return u("int32array:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_float32array: function(e) {
+								return u("float32array:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_float64array: function(e) {
+								return u("float64array:"), this.dispatch(Array.prototype.slice.call(e));
+							},
+							_arraybuffer: function(e) {
+								return u("arraybuffer:"), this.dispatch(new Uint8Array(e));
+							},
+							_url: function(e) {
+								return u("url:" + e.toString());
+							},
+							_map: function(e) {
+								u("map:");
+								e = Array.from(e);
+								return this._array(e, !1 !== o.unorderedSets);
+							},
+							_set: function(e) {
+								u("set:");
+								e = Array.from(e);
+								return this._array(e, !1 !== o.unorderedSets);
+							},
+							_file: function(e) {
+								return u("file:"), this.dispatch([
+									e.name,
+									e.size,
+									e.type,
+									e.lastModfied
+								]);
+							},
+							_blob: function() {
+								if (o.ignoreUnknown) return u("[blob]");
+								throw Error("Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse \"options.replacer\" or \"options.ignoreUnknown\"\n");
+							},
+							_domwindow: function() {
+								return u("domwindow");
+							},
+							_bigint: function(e) {
+								return u("bigint:" + e.toString());
+							},
+							_process: function() {
+								return u("process");
+							},
+							_timer: function() {
+								return u("timer");
+							},
+							_pipe: function() {
+								return u("pipe");
+							},
+							_tcp: function() {
+								return u("tcp");
+							},
+							_udp: function() {
+								return u("udp");
+							},
+							_tty: function() {
+								return u("tty");
+							},
+							_statwatcher: function() {
+								return u("statwatcher");
+							},
+							_securecontext: function() {
+								return u("securecontext");
+							},
+							_connection: function() {
+								return u("connection");
+							},
+							_zlib: function() {
+								return u("zlib");
+							},
+							_context: function() {
+								return u("context");
+							},
+							_nodescript: function() {
+								return u("nodescript");
+							},
+							_httpparser: function() {
+								return u("httpparser");
+							},
+							_dataview: function() {
+								return u("dataview");
+							},
+							_signal: function() {
+								return u("signal");
+							},
+							_fsevent: function() {
+								return u("fsevent");
+							},
+							_tlswrap: function() {
+								return u("tlswrap");
+							}
+						};
+					}
+					function l() {
+						return {
+							buf: "",
+							write: function(e) {
+								this.buf += e;
+							},
+							end: function(e) {
+								this.buf += e;
+							},
+							read: function() {
+								return this.buf;
+							}
+						};
+					}
+					m.writeToStream = function(e, t, n) {
+						return void 0 === n && (n = t, t = {}), f(t = u(e, t), n).dispatch(e);
+					};
+				}).call(this, w("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, w("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/fake_9a5aa49d.js", "/");
+			}, {
+				buffer: 3,
+				crypto: 5,
+				lYpoI2: 11
+			}],
+			2: [function(e, t, f) {
+				(function(e, t, n, r, o, i, u, s, a) {
+					(function(e) {
+						"use strict";
+						var a = "undefined" != typeof Uint8Array ? Uint8Array : Array, t = "+".charCodeAt(0), n = "/".charCodeAt(0), r = "0".charCodeAt(0), o = "a".charCodeAt(0), i = "A".charCodeAt(0), u = "-".charCodeAt(0), s = "_".charCodeAt(0);
+						function f(e) {
+							e = e.charCodeAt(0);
+							return e === t || e === u ? 62 : e === n || e === s ? 63 : e < r ? -1 : e < r + 10 ? e - r + 26 + 26 : e < i + 26 ? e - i : e < o + 26 ? e - o + 26 : void 0;
+						}
+						e.toByteArray = function(e) {
+							var t, n;
+							if (0 < e.length % 4) throw new Error("Invalid string. Length must be a multiple of 4");
+							var r = e.length, r = "=" === e.charAt(r - 2) ? 2 : "=" === e.charAt(r - 1) ? 1 : 0, o = new a(3 * e.length / 4 - r), i = 0 < r ? e.length - 4 : e.length, u = 0;
+							function s(e) {
+								o[u++] = e;
+							}
+							for (t = 0; t < i; t += 4) s((16711680 & (n = f(e.charAt(t)) << 18 | f(e.charAt(t + 1)) << 12 | f(e.charAt(t + 2)) << 6 | f(e.charAt(t + 3)))) >> 16), s((65280 & n) >> 8), s(255 & n);
+							return 2 == r ? s(255 & (n = f(e.charAt(t)) << 2 | f(e.charAt(t + 1)) >> 4)) : 1 == r && (s((n = f(e.charAt(t)) << 10 | f(e.charAt(t + 1)) << 4 | f(e.charAt(t + 2)) >> 2) >> 8 & 255), s(255 & n)), o;
+						}, e.fromByteArray = function(e) {
+							var t, n, r, o, i = e.length % 3, u = "";
+							function s(e) {
+								return "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(e);
+							}
+							for (t = 0, r = e.length - i; t < r; t += 3) n = (e[t] << 16) + (e[t + 1] << 8) + e[t + 2], u += s((o = n) >> 18 & 63) + s(o >> 12 & 63) + s(o >> 6 & 63) + s(63 & o);
+							switch (i) {
+								case 1:
+									u = (u += s((n = e[e.length - 1]) >> 2)) + s(n << 4 & 63) + "==";
+									break;
+								case 2: u = (u = (u += s((n = (e[e.length - 2] << 8) + e[e.length - 1]) >> 10)) + s(n >> 4 & 63)) + s(n << 2 & 63) + "=";
+							}
+							return u;
+						};
+					})(void 0 === f ? this.base64js = {} : f);
+				}).call(this, e("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, e("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/base64-js/lib/b64.js", "/node_modules/gulp-browserify/node_modules/base64-js/lib");
+			}, {
+				buffer: 3,
+				lYpoI2: 11
+			}],
+			3: [function(O, e, H) {
+				(function(e, n, f, r, h, p, g, y, w) {
+					var a = O("base64-js"), i = O("ieee754");
+					function f(e, t, n) {
+						if (!(this instanceof f)) return new f(e, t, n);
+						var r, o, i, u, s = typeof e;
+						if ("base64" === t && "string" == s) for (e = (u = e).trim ? u.trim() : u.replace(/^\s+|\s+$/g, ""); e.length % 4 != 0;) e += "=";
+						if ("number" == s) r = j(e);
+						else if ("string" == s) r = f.byteLength(e, t);
+						else {
+							if ("object" != s) throw new Error("First argument needs to be a number, array or string.");
+							r = j(e.length);
+						}
+						if (f._useTypedArrays ? o = f._augment(new Uint8Array(r)) : ((o = this).length = r, o._isBuffer = !0), f._useTypedArrays && "number" == typeof e.byteLength) o._set(e);
+						else if (C(u = e) || f.isBuffer(u) || u && "object" == typeof u && "number" == typeof u.length) for (i = 0; i < r; i++) f.isBuffer(e) ? o[i] = e.readUInt8(i) : o[i] = e[i];
+						else if ("string" == s) o.write(e, 0, t);
+						else if ("number" == s && !f._useTypedArrays && !n) for (i = 0; i < r; i++) o[i] = 0;
+						return o;
+					}
+					function b(e, t, n, r) {
+						return f._charsWritten = c(function(e) {
+							for (var t = [], n = 0; n < e.length; n++) t.push(255 & e.charCodeAt(n));
+							return t;
+						}(t), e, n, r);
+					}
+					function m(e, t, n, r) {
+						return f._charsWritten = c(function(e) {
+							for (var t, n, r = [], o = 0; o < e.length; o++) n = e.charCodeAt(o), t = n >> 8, n = n % 256, r.push(n), r.push(t);
+							return r;
+						}(t), e, n, r);
+					}
+					function v(e, t, n) {
+						var r = "";
+						n = Math.min(e.length, n);
+						for (var o = t; o < n; o++) r += String.fromCharCode(e[o]);
+						return r;
+					}
+					function o(e, t, n, r) {
+						r || (d("boolean" == typeof n, "missing or invalid endian"), d(null != t, "missing offset"), d(t + 1 < e.length, "Trying to read beyond buffer length"));
+						var o, r = e.length;
+						if (!(r <= t)) return n ? (o = e[t], t + 1 < r && (o |= e[t + 1] << 8)) : (o = e[t] << 8, t + 1 < r && (o |= e[t + 1])), o;
+					}
+					function u(e, t, n, r) {
+						r || (d("boolean" == typeof n, "missing or invalid endian"), d(null != t, "missing offset"), d(t + 3 < e.length, "Trying to read beyond buffer length"));
+						var o, r = e.length;
+						if (!(r <= t)) return n ? (t + 2 < r && (o = e[t + 2] << 16), t + 1 < r && (o |= e[t + 1] << 8), o |= e[t], t + 3 < r && (o += e[t + 3] << 24 >>> 0)) : (t + 1 < r && (o = e[t + 1] << 16), t + 2 < r && (o |= e[t + 2] << 8), t + 3 < r && (o |= e[t + 3]), o += e[t] << 24 >>> 0), o;
+					}
+					function _(e, t, n, r) {
+						if (r || (d("boolean" == typeof n, "missing or invalid endian"), d(null != t, "missing offset"), d(t + 1 < e.length, "Trying to read beyond buffer length")), !(e.length <= t)) return r = o(e, t, n, !0), 32768 & r ? -1 * (65535 - r + 1) : r;
+					}
+					function E(e, t, n, r) {
+						if (r || (d("boolean" == typeof n, "missing or invalid endian"), d(null != t, "missing offset"), d(t + 3 < e.length, "Trying to read beyond buffer length")), !(e.length <= t)) return r = u(e, t, n, !0), 2147483648 & r ? -1 * (4294967295 - r + 1) : r;
+					}
+					function I(e, t, n, r) {
+						return r || (d("boolean" == typeof n, "missing or invalid endian"), d(t + 3 < e.length, "Trying to read beyond buffer length")), i.read(e, t, n, 23, 4);
+					}
+					function A(e, t, n, r) {
+						return r || (d("boolean" == typeof n, "missing or invalid endian"), d(t + 7 < e.length, "Trying to read beyond buffer length")), i.read(e, t, n, 52, 8);
+					}
+					function s(e, t, n, r, o) {
+						o || (d(null != t, "missing value"), d("boolean" == typeof r, "missing or invalid endian"), d(null != n, "missing offset"), d(n + 1 < e.length, "trying to write beyond buffer length"), Y(t, 65535));
+						o = e.length;
+						if (!(o <= n)) for (var i = 0, u = Math.min(o - n, 2); i < u; i++) e[n + i] = (t & 255 << 8 * (r ? i : 1 - i)) >>> 8 * (r ? i : 1 - i);
+					}
+					function l(e, t, n, r, o) {
+						o || (d(null != t, "missing value"), d("boolean" == typeof r, "missing or invalid endian"), d(null != n, "missing offset"), d(n + 3 < e.length, "trying to write beyond buffer length"), Y(t, 4294967295));
+						o = e.length;
+						if (!(o <= n)) for (var i = 0, u = Math.min(o - n, 4); i < u; i++) e[n + i] = t >>> 8 * (r ? i : 3 - i) & 255;
+					}
+					function B(e, t, n, r, o) {
+						o || (d(null != t, "missing value"), d("boolean" == typeof r, "missing or invalid endian"), d(null != n, "missing offset"), d(n + 1 < e.length, "Trying to write beyond buffer length"), F(t, 32767, -32768)), e.length <= n || s(e, 0 <= t ? t : 65535 + t + 1, n, r, o);
+					}
+					function L(e, t, n, r, o) {
+						o || (d(null != t, "missing value"), d("boolean" == typeof r, "missing or invalid endian"), d(null != n, "missing offset"), d(n + 3 < e.length, "Trying to write beyond buffer length"), F(t, 2147483647, -2147483648)), e.length <= n || l(e, 0 <= t ? t : 4294967295 + t + 1, n, r, o);
+					}
+					function U(e, t, n, r, o) {
+						o || (d(null != t, "missing value"), d("boolean" == typeof r, "missing or invalid endian"), d(null != n, "missing offset"), d(n + 3 < e.length, "Trying to write beyond buffer length"), D(t, 34028234663852886e22, -34028234663852886e22)), e.length <= n || i.write(e, t, n, r, 23, 4);
+					}
+					function x(e, t, n, r, o) {
+						o || (d(null != t, "missing value"), d("boolean" == typeof r, "missing or invalid endian"), d(null != n, "missing offset"), d(n + 7 < e.length, "Trying to write beyond buffer length"), D(t, 17976931348623157e292, -17976931348623157e292)), e.length <= n || i.write(e, t, n, r, 52, 8);
+					}
+					H.Buffer = f, H.SlowBuffer = f, H.INSPECT_MAX_BYTES = 50, f.poolSize = 8192, f._useTypedArrays = function() {
+						try {
+							var t = new Uint8Array(/* @__PURE__ */ new ArrayBuffer(0));
+							return t.foo = function() {
+								return 42;
+							}, 42 === t.foo() && "function" == typeof t.subarray;
+						} catch (e) {
+							return !1;
+						}
+					}(), f.isEncoding = function(e) {
+						switch (String(e).toLowerCase()) {
+							case "hex":
+							case "utf8":
+							case "utf-8":
+							case "ascii":
+							case "binary":
+							case "base64":
+							case "raw":
+							case "ucs2":
+							case "ucs-2":
+							case "utf16le":
+							case "utf-16le": return !0;
+							default: return !1;
+						}
+					}, f.isBuffer = function(e) {
+						return !(null == e || !e._isBuffer);
+					}, f.byteLength = function(e, t) {
+						var n;
+						switch (e += "", t || "utf8") {
+							case "hex":
+								n = e.length / 2;
+								break;
+							case "utf8":
+							case "utf-8":
+								n = T(e).length;
+								break;
+							case "ascii":
+							case "binary":
+							case "raw":
+								n = e.length;
+								break;
+							case "base64":
+								n = M(e).length;
+								break;
+							case "ucs2":
+							case "ucs-2":
+							case "utf16le":
+							case "utf-16le":
+								n = 2 * e.length;
+								break;
+							default: throw new Error("Unknown encoding");
+						}
+						return n;
+					}, f.concat = function(e, t) {
+						if (d(C(e), "Usage: Buffer.concat(list, [totalLength])\nlist should be an Array."), 0 === e.length) return new f(0);
+						if (1 === e.length) return e[0];
+						if ("number" != typeof t) for (o = t = 0; o < e.length; o++) t += e[o].length;
+						for (var n = new f(t), r = 0, o = 0; o < e.length; o++) {
+							var i = e[o];
+							i.copy(n, r), r += i.length;
+						}
+						return n;
+					}, f.prototype.write = function(e, t, n, r) {
+						isFinite(t) ? isFinite(n) || (r = n, n = void 0) : (a = r, r = t, t = n, n = a), t = Number(t) || 0;
+						var o, i, u, s, a = this.length - t;
+						switch ((!n || a < (n = Number(n))) && (n = a), r = String(r || "utf8").toLowerCase()) {
+							case "hex":
+								o = function(e, t, n, r) {
+									n = Number(n) || 0;
+									var o = e.length - n;
+									(!r || o < (r = Number(r))) && (r = o), d((o = t.length) % 2 == 0, "Invalid hex string"), o / 2 < r && (r = o / 2);
+									for (var i = 0; i < r; i++) {
+										var u = parseInt(t.substr(2 * i, 2), 16);
+										d(!isNaN(u), "Invalid hex string"), e[n + i] = u;
+									}
+									return f._charsWritten = 2 * i, i;
+								}(this, e, t, n);
+								break;
+							case "utf8":
+							case "utf-8":
+								i = this, u = t, s = n, o = f._charsWritten = c(T(e), i, u, s);
+								break;
+							case "ascii":
+							case "binary":
+								o = b(this, e, t, n);
+								break;
+							case "base64":
+								i = this, u = t, s = n, o = f._charsWritten = c(M(e), i, u, s);
+								break;
+							case "ucs2":
+							case "ucs-2":
+							case "utf16le":
+							case "utf-16le":
+								o = m(this, e, t, n);
+								break;
+							default: throw new Error("Unknown encoding");
+						}
+						return o;
+					}, f.prototype.toString = function(e, t, n) {
+						var r, o, i, u, s = this;
+						if (e = String(e || "utf8").toLowerCase(), t = Number(t) || 0, (n = void 0 !== n ? Number(n) : s.length) === t) return "";
+						switch (e) {
+							case "hex":
+								r = function(e, t, n) {
+									var r = e.length;
+									(!t || t < 0) && (t = 0);
+									(!n || n < 0 || r < n) && (n = r);
+									for (var o = "", i = t; i < n; i++) o += k(e[i]);
+									return o;
+								}(s, t, n);
+								break;
+							case "utf8":
+							case "utf-8":
+								r = function(e, t, n) {
+									var r = "", o = "";
+									n = Math.min(e.length, n);
+									for (var i = t; i < n; i++) e[i] <= 127 ? (r += N(o) + String.fromCharCode(e[i]), o = "") : o += "%" + e[i].toString(16);
+									return r + N(o);
+								}(s, t, n);
+								break;
+							case "ascii":
+							case "binary":
+								r = v(s, t, n);
+								break;
+							case "base64":
+								o = s, u = n, r = 0 === (i = t) && u === o.length ? a.fromByteArray(o) : a.fromByteArray(o.slice(i, u));
+								break;
+							case "ucs2":
+							case "ucs-2":
+							case "utf16le":
+							case "utf-16le":
+								r = function(e, t, n) {
+									for (var r = e.slice(t, n), o = "", i = 0; i < r.length; i += 2) o += String.fromCharCode(r[i] + 256 * r[i + 1]);
+									return o;
+								}(s, t, n);
+								break;
+							default: throw new Error("Unknown encoding");
+						}
+						return r;
+					}, f.prototype.toJSON = function() {
+						return {
+							type: "Buffer",
+							data: Array.prototype.slice.call(this._arr || this, 0)
+						};
+					}, f.prototype.copy = function(e, t, n, r) {
+						if (t = t || 0, (r = r || 0 === r ? r : this.length) !== (n = n || 0) && 0 !== e.length && 0 !== this.length) {
+							d(n <= r, "sourceEnd < sourceStart"), d(0 <= t && t < e.length, "targetStart out of bounds"), d(0 <= n && n < this.length, "sourceStart out of bounds"), d(0 <= r && r <= this.length, "sourceEnd out of bounds"), r > this.length && (r = this.length);
+							var o = (r = e.length - t < r - n ? e.length - t + n : r) - n;
+							if (o < 100 || !f._useTypedArrays) for (var i = 0; i < o; i++) e[i + t] = this[i + n];
+							else e._set(this.subarray(n, n + o), t);
+						}
+					}, f.prototype.slice = function(e, t) {
+						var n = this.length;
+						if (e = S(e, n, 0), t = S(t, n, n), f._useTypedArrays) return f._augment(this.subarray(e, t));
+						for (var r = t - e, o = new f(r, void 0, !0), i = 0; i < r; i++) o[i] = this[i + e];
+						return o;
+					}, f.prototype.get = function(e) {
+						return console.log(".get() is deprecated. Access using array indexes instead."), this.readUInt8(e);
+					}, f.prototype.set = function(e, t) {
+						return console.log(".set() is deprecated. Access using array indexes instead."), this.writeUInt8(e, t);
+					}, f.prototype.readUInt8 = function(e, t) {
+						if (t || (d(null != e, "missing offset"), d(e < this.length, "Trying to read beyond buffer length")), !(e >= this.length)) return this[e];
+					}, f.prototype.readUInt16LE = function(e, t) {
+						return o(this, e, !0, t);
+					}, f.prototype.readUInt16BE = function(e, t) {
+						return o(this, e, !1, t);
+					}, f.prototype.readUInt32LE = function(e, t) {
+						return u(this, e, !0, t);
+					}, f.prototype.readUInt32BE = function(e, t) {
+						return u(this, e, !1, t);
+					}, f.prototype.readInt8 = function(e, t) {
+						if (t || (d(null != e, "missing offset"), d(e < this.length, "Trying to read beyond buffer length")), !(e >= this.length)) return 128 & this[e] ? -1 * (255 - this[e] + 1) : this[e];
+					}, f.prototype.readInt16LE = function(e, t) {
+						return _(this, e, !0, t);
+					}, f.prototype.readInt16BE = function(e, t) {
+						return _(this, e, !1, t);
+					}, f.prototype.readInt32LE = function(e, t) {
+						return E(this, e, !0, t);
+					}, f.prototype.readInt32BE = function(e, t) {
+						return E(this, e, !1, t);
+					}, f.prototype.readFloatLE = function(e, t) {
+						return I(this, e, !0, t);
+					}, f.prototype.readFloatBE = function(e, t) {
+						return I(this, e, !1, t);
+					}, f.prototype.readDoubleLE = function(e, t) {
+						return A(this, e, !0, t);
+					}, f.prototype.readDoubleBE = function(e, t) {
+						return A(this, e, !1, t);
+					}, f.prototype.writeUInt8 = function(e, t, n) {
+						n || (d(null != e, "missing value"), d(null != t, "missing offset"), d(t < this.length, "trying to write beyond buffer length"), Y(e, 255)), t >= this.length || (this[t] = e);
+					}, f.prototype.writeUInt16LE = function(e, t, n) {
+						s(this, e, t, !0, n);
+					}, f.prototype.writeUInt16BE = function(e, t, n) {
+						s(this, e, t, !1, n);
+					}, f.prototype.writeUInt32LE = function(e, t, n) {
+						l(this, e, t, !0, n);
+					}, f.prototype.writeUInt32BE = function(e, t, n) {
+						l(this, e, t, !1, n);
+					}, f.prototype.writeInt8 = function(e, t, n) {
+						n || (d(null != e, "missing value"), d(null != t, "missing offset"), d(t < this.length, "Trying to write beyond buffer length"), F(e, 127, -128)), t >= this.length || (0 <= e ? this.writeUInt8(e, t, n) : this.writeUInt8(255 + e + 1, t, n));
+					}, f.prototype.writeInt16LE = function(e, t, n) {
+						B(this, e, t, !0, n);
+					}, f.prototype.writeInt16BE = function(e, t, n) {
+						B(this, e, t, !1, n);
+					}, f.prototype.writeInt32LE = function(e, t, n) {
+						L(this, e, t, !0, n);
+					}, f.prototype.writeInt32BE = function(e, t, n) {
+						L(this, e, t, !1, n);
+					}, f.prototype.writeFloatLE = function(e, t, n) {
+						U(this, e, t, !0, n);
+					}, f.prototype.writeFloatBE = function(e, t, n) {
+						U(this, e, t, !1, n);
+					}, f.prototype.writeDoubleLE = function(e, t, n) {
+						x(this, e, t, !0, n);
+					}, f.prototype.writeDoubleBE = function(e, t, n) {
+						x(this, e, t, !1, n);
+					}, f.prototype.fill = function(e, t, n) {
+						if (t = t || 0, n = n || this.length, d("number" == typeof (e = "string" == typeof (e = e || 0) ? e.charCodeAt(0) : e) && !isNaN(e), "value is not a number"), d(t <= n, "end < start"), n !== t && 0 !== this.length) {
+							d(0 <= t && t < this.length, "start out of bounds"), d(0 <= n && n <= this.length, "end out of bounds");
+							for (var r = t; r < n; r++) this[r] = e;
+						}
+					}, f.prototype.inspect = function() {
+						for (var e = [], t = this.length, n = 0; n < t; n++) if (e[n] = k(this[n]), n === H.INSPECT_MAX_BYTES) {
+							e[n + 1] = "...";
+							break;
+						}
+						return "<Buffer " + e.join(" ") + ">";
+					}, f.prototype.toArrayBuffer = function() {
+						if ("undefined" == typeof Uint8Array) throw new Error("Buffer.toArrayBuffer not supported in this browser");
+						if (f._useTypedArrays) return new f(this).buffer;
+						for (var e = new Uint8Array(this.length), t = 0, n = e.length; t < n; t += 1) e[t] = this[t];
+						return e.buffer;
+					};
+					var t = f.prototype;
+					function S(e, t, n) {
+						return "number" != typeof e ? n : t <= (e = ~~e) ? t : 0 <= e || 0 <= (e += t) ? e : 0;
+					}
+					function j(e) {
+						return (e = ~~Math.ceil(+e)) < 0 ? 0 : e;
+					}
+					function C(e) {
+						return (Array.isArray || function(e) {
+							return "[object Array]" === Object.prototype.toString.call(e);
+						})(e);
+					}
+					function k(e) {
+						return e < 16 ? "0" + e.toString(16) : e.toString(16);
+					}
+					function T(e) {
+						for (var t = [], n = 0; n < e.length; n++) {
+							var r = e.charCodeAt(n);
+							if (r <= 127) t.push(e.charCodeAt(n));
+							else for (var o = n, i = (55296 <= r && r <= 57343 && n++, encodeURIComponent(e.slice(o, n + 1)).substr(1).split("%")), u = 0; u < i.length; u++) t.push(parseInt(i[u], 16));
+						}
+						return t;
+					}
+					function M(e) {
+						return a.toByteArray(e);
+					}
+					function c(e, t, n, r) {
+						for (var o = 0; o < r && !(o + n >= t.length || o >= e.length); o++) t[o + n] = e[o];
+						return o;
+					}
+					function N(e) {
+						try {
+							return decodeURIComponent(e);
+						} catch (e) {
+							return String.fromCharCode(65533);
+						}
+					}
+					function Y(e, t) {
+						d("number" == typeof e, "cannot write a non-number as a number"), d(0 <= e, "specified a negative value for writing an unsigned value"), d(e <= t, "value is larger than maximum value for type"), d(Math.floor(e) === e, "value has a fractional component");
+					}
+					function F(e, t, n) {
+						d("number" == typeof e, "cannot write a non-number as a number"), d(e <= t, "value larger than maximum allowed value"), d(n <= e, "value smaller than minimum allowed value"), d(Math.floor(e) === e, "value has a fractional component");
+					}
+					function D(e, t, n) {
+						d("number" == typeof e, "cannot write a non-number as a number"), d(e <= t, "value larger than maximum allowed value"), d(n <= e, "value smaller than minimum allowed value");
+					}
+					function d(e, t) {
+						if (!e) throw new Error(t || "Failed assertion");
+					}
+					f._augment = function(e) {
+						return e._isBuffer = !0, e._get = e.get, e._set = e.set, e.get = t.get, e.set = t.set, e.write = t.write, e.toString = t.toString, e.toLocaleString = t.toString, e.toJSON = t.toJSON, e.copy = t.copy, e.slice = t.slice, e.readUInt8 = t.readUInt8, e.readUInt16LE = t.readUInt16LE, e.readUInt16BE = t.readUInt16BE, e.readUInt32LE = t.readUInt32LE, e.readUInt32BE = t.readUInt32BE, e.readInt8 = t.readInt8, e.readInt16LE = t.readInt16LE, e.readInt16BE = t.readInt16BE, e.readInt32LE = t.readInt32LE, e.readInt32BE = t.readInt32BE, e.readFloatLE = t.readFloatLE, e.readFloatBE = t.readFloatBE, e.readDoubleLE = t.readDoubleLE, e.readDoubleBE = t.readDoubleBE, e.writeUInt8 = t.writeUInt8, e.writeUInt16LE = t.writeUInt16LE, e.writeUInt16BE = t.writeUInt16BE, e.writeUInt32LE = t.writeUInt32LE, e.writeUInt32BE = t.writeUInt32BE, e.writeInt8 = t.writeInt8, e.writeInt16LE = t.writeInt16LE, e.writeInt16BE = t.writeInt16BE, e.writeInt32LE = t.writeInt32LE, e.writeInt32BE = t.writeInt32BE, e.writeFloatLE = t.writeFloatLE, e.writeFloatBE = t.writeFloatBE, e.writeDoubleLE = t.writeDoubleLE, e.writeDoubleBE = t.writeDoubleBE, e.fill = t.fill, e.inspect = t.inspect, e.toArrayBuffer = t.toArrayBuffer, e;
+					};
+				}).call(this, O("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, O("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/buffer/index.js", "/node_modules/gulp-browserify/node_modules/buffer");
+			}, {
+				"base64-js": 2,
+				buffer: 3,
+				ieee754: 10,
+				lYpoI2: 11
+			}],
+			4: [function(c, d, e) {
+				(function(e, t, a, n, r, o, i, u, s) {
+					var a = c("buffer").Buffer, f = 4, l = new a(f);
+					l.fill(0);
+					d.exports = { hash: function(e, t, n, r) {
+						for (var o = t(function(e, t) {
+							e.length % f != 0 && (n = e.length + (f - e.length % f), e = a.concat([e, l], n));
+							for (var n, r = [], o = t ? e.readInt32BE : e.readInt32LE, i = 0; i < e.length; i += f) r.push(o.call(e, i));
+							return r;
+						}(e = a.isBuffer(e) ? e : new a(e), r), 8 * e.length), t = r, i = new a(n), u = t ? i.writeInt32BE : i.writeInt32LE, s = 0; s < o.length; s++) u.call(i, o[s], 4 * s, !0);
+						return i;
+					} };
+				}).call(this, c("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, c("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/helpers.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+			}, {
+				buffer: 3,
+				lYpoI2: 11
+			}],
+			5: [function(v, e, _) {
+				(function(l, c, u, d, h, p, g, y, w) {
+					var u = v("buffer").Buffer, e = v("./sha"), t = v("./sha256"), n = v("./rng"), b = {
+						sha1: e,
+						sha256: t,
+						md5: v("./md5")
+					}, s = 64, a = new u(s);
+					function r(e, n) {
+						var r = b[e = e || "sha1"], o = [];
+						return r || i("algorithm:", e, "is not yet supported"), {
+							update: function(e) {
+								return u.isBuffer(e) || (e = new u(e)), o.push(e), e.length, this;
+							},
+							digest: function(e) {
+								var t = u.concat(o), t = n ? function(e, t, n) {
+									u.isBuffer(t) || (t = new u(t)), u.isBuffer(n) || (n = new u(n)), t.length > s ? t = e(t) : t.length < s && (t = u.concat([t, a], s));
+									for (var r = new u(s), o = new u(s), i = 0; i < s; i++) r[i] = 54 ^ t[i], o[i] = 92 ^ t[i];
+									return n = e(u.concat([r, n])), e(u.concat([o, n]));
+								}(r, n, t) : r(t);
+								return o = null, e ? t.toString(e) : t;
+							}
+						};
+					}
+					function i() {
+						var e = [].slice.call(arguments).join(" ");
+						throw new Error([
+							e,
+							"we accept pull requests",
+							"http://github.com/dominictarr/crypto-browserify"
+						].join("\n"));
+					}
+					a.fill(0), _.createHash = function(e) {
+						return r(e);
+					}, _.createHmac = r, _.randomBytes = function(e, t) {
+						if (!t || !t.call) return new u(n(e));
+						try {
+							t.call(this, void 0, new u(n(e)));
+						} catch (e) {
+							t(e);
+						}
+					};
+					var o, f = [
+						"createCredentials",
+						"createCipher",
+						"createCipheriv",
+						"createDecipher",
+						"createDecipheriv",
+						"createSign",
+						"createVerify",
+						"createDiffieHellman",
+						"pbkdf2"
+					], m = function(e) {
+						_[e] = function() {
+							i("sorry,", e, "is not implemented yet");
+						};
+					};
+					for (o in f) m(f[o], o);
+				}).call(this, v("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, v("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/index.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+			}, {
+				"./md5": 6,
+				"./rng": 7,
+				"./sha": 8,
+				"./sha256": 9,
+				buffer: 3,
+				lYpoI2: 11
+			}],
+			6: [function(w, b, e) {
+				(function(e, r, o, i, u, a, f, l, y) {
+					var t = w("./helpers");
+					function n(e, t) {
+						e[t >> 5] |= 128 << t % 32, e[14 + (t + 64 >>> 9 << 4)] = t;
+						for (var n = 1732584193, r = -271733879, o = -1732584194, i = 271733878, u = 0; u < e.length; u += 16) {
+							var s = n, a = r, f = o, l = i, n = c(n, r, o, i, e[u + 0], 7, -680876936), i = c(i, n, r, o, e[u + 1], 12, -389564586), o = c(o, i, n, r, e[u + 2], 17, 606105819), r = c(r, o, i, n, e[u + 3], 22, -1044525330);
+							n = c(n, r, o, i, e[u + 4], 7, -176418897), i = c(i, n, r, o, e[u + 5], 12, 1200080426), o = c(o, i, n, r, e[u + 6], 17, -1473231341), r = c(r, o, i, n, e[u + 7], 22, -45705983), n = c(n, r, o, i, e[u + 8], 7, 1770035416), i = c(i, n, r, o, e[u + 9], 12, -1958414417), o = c(o, i, n, r, e[u + 10], 17, -42063), r = c(r, o, i, n, e[u + 11], 22, -1990404162), n = c(n, r, o, i, e[u + 12], 7, 1804603682), i = c(i, n, r, o, e[u + 13], 12, -40341101), o = c(o, i, n, r, e[u + 14], 17, -1502002290), n = d(n, r = c(r, o, i, n, e[u + 15], 22, 1236535329), o, i, e[u + 1], 5, -165796510), i = d(i, n, r, o, e[u + 6], 9, -1069501632), o = d(o, i, n, r, e[u + 11], 14, 643717713), r = d(r, o, i, n, e[u + 0], 20, -373897302), n = d(n, r, o, i, e[u + 5], 5, -701558691), i = d(i, n, r, o, e[u + 10], 9, 38016083), o = d(o, i, n, r, e[u + 15], 14, -660478335), r = d(r, o, i, n, e[u + 4], 20, -405537848), n = d(n, r, o, i, e[u + 9], 5, 568446438), i = d(i, n, r, o, e[u + 14], 9, -1019803690), o = d(o, i, n, r, e[u + 3], 14, -187363961), r = d(r, o, i, n, e[u + 8], 20, 1163531501), n = d(n, r, o, i, e[u + 13], 5, -1444681467), i = d(i, n, r, o, e[u + 2], 9, -51403784), o = d(o, i, n, r, e[u + 7], 14, 1735328473), n = h(n, r = d(r, o, i, n, e[u + 12], 20, -1926607734), o, i, e[u + 5], 4, -378558), i = h(i, n, r, o, e[u + 8], 11, -2022574463), o = h(o, i, n, r, e[u + 11], 16, 1839030562), r = h(r, o, i, n, e[u + 14], 23, -35309556), n = h(n, r, o, i, e[u + 1], 4, -1530992060), i = h(i, n, r, o, e[u + 4], 11, 1272893353), o = h(o, i, n, r, e[u + 7], 16, -155497632), r = h(r, o, i, n, e[u + 10], 23, -1094730640), n = h(n, r, o, i, e[u + 13], 4, 681279174), i = h(i, n, r, o, e[u + 0], 11, -358537222), o = h(o, i, n, r, e[u + 3], 16, -722521979), r = h(r, o, i, n, e[u + 6], 23, 76029189), n = h(n, r, o, i, e[u + 9], 4, -640364487), i = h(i, n, r, o, e[u + 12], 11, -421815835), o = h(o, i, n, r, e[u + 15], 16, 530742520), n = p(n, r = h(r, o, i, n, e[u + 2], 23, -995338651), o, i, e[u + 0], 6, -198630844), i = p(i, n, r, o, e[u + 7], 10, 1126891415), o = p(o, i, n, r, e[u + 14], 15, -1416354905), r = p(r, o, i, n, e[u + 5], 21, -57434055), n = p(n, r, o, i, e[u + 12], 6, 1700485571), i = p(i, n, r, o, e[u + 3], 10, -1894986606), o = p(o, i, n, r, e[u + 10], 15, -1051523), r = p(r, o, i, n, e[u + 1], 21, -2054922799), n = p(n, r, o, i, e[u + 8], 6, 1873313359), i = p(i, n, r, o, e[u + 15], 10, -30611744), o = p(o, i, n, r, e[u + 6], 15, -1560198380), r = p(r, o, i, n, e[u + 13], 21, 1309151649), n = p(n, r, o, i, e[u + 4], 6, -145523070), i = p(i, n, r, o, e[u + 11], 10, -1120210379), o = p(o, i, n, r, e[u + 2], 15, 718787259), r = p(r, o, i, n, e[u + 9], 21, -343485551), n = g(n, s), r = g(r, a), o = g(o, f), i = g(i, l);
+						}
+						return Array(n, r, o, i);
+					}
+					function s(e, t, n, r, o, i) {
+						return g((t = g(g(t, e), g(r, i))) << o | t >>> 32 - o, n);
+					}
+					function c(e, t, n, r, o, i, u) {
+						return s(t & n | ~t & r, e, t, o, i, u);
+					}
+					function d(e, t, n, r, o, i, u) {
+						return s(t & r | n & ~r, e, t, o, i, u);
+					}
+					function h(e, t, n, r, o, i, u) {
+						return s(t ^ n ^ r, e, t, o, i, u);
+					}
+					function p(e, t, n, r, o, i, u) {
+						return s(n ^ (t | ~r), e, t, o, i, u);
+					}
+					function g(e, t) {
+						var n = (65535 & e) + (65535 & t);
+						return (e >> 16) + (t >> 16) + (n >> 16) << 16 | 65535 & n;
+					}
+					b.exports = function(e) {
+						return t.hash(e, n, 16);
+					};
+				}).call(this, w("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, w("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/md5.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+			}, {
+				"./helpers": 4,
+				buffer: 3,
+				lYpoI2: 11
+			}],
+			7: [function(e, l, t) {
+				(function(e, t, n, r, o, i, u, s, f) {
+					var a;
+					l.exports = a || function(e) {
+						for (var t, n = new Array(e), r = 0; r < e; r++) 0 == (3 & r) && (t = 4294967296 * Math.random()), n[r] = t >>> ((3 & r) << 3) & 255;
+						return n;
+					};
+				}).call(this, e("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, e("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/rng.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+			}, {
+				buffer: 3,
+				lYpoI2: 11
+			}],
+			8: [function(c, d, e) {
+				(function(e, t, n, r, o, s, a, f, l) {
+					var i = c("./helpers");
+					function u(l, c) {
+						l[c >> 5] |= 128 << 24 - c % 32, l[15 + (c + 64 >> 9 << 4)] = c;
+						for (var e, t, n, r = Array(80), o = 1732584193, i = -271733879, u = -1732584194, s = 271733878, d = -1009589776, h = 0; h < l.length; h += 16) {
+							for (var p = o, g = i, y = u, w = s, b = d, a = 0; a < 80; a++) {
+								r[a] = a < 16 ? l[h + a] : v(r[a - 3] ^ r[a - 8] ^ r[a - 14] ^ r[a - 16], 1);
+								var f = m(m(v(o, 5), (f = i, t = u, n = s, (e = a) < 20 ? f & t | ~f & n : !(e < 40) && e < 60 ? f & t | f & n | t & n : f ^ t ^ n)), m(m(d, r[a]), (e = a) < 20 ? 1518500249 : e < 40 ? 1859775393 : e < 60 ? -1894007588 : -899497514)), d = s, s = u, u = v(i, 30), i = o, o = f;
+							}
+							o = m(o, p), i = m(i, g), u = m(u, y), s = m(s, w), d = m(d, b);
+						}
+						return Array(o, i, u, s, d);
+					}
+					function m(e, t) {
+						var n = (65535 & e) + (65535 & t);
+						return (e >> 16) + (t >> 16) + (n >> 16) << 16 | 65535 & n;
+					}
+					function v(e, t) {
+						return e << t | e >>> 32 - t;
+					}
+					d.exports = function(e) {
+						return i.hash(e, u, 20, !0);
+					};
+				}).call(this, c("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, c("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/sha.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+			}, {
+				"./helpers": 4,
+				buffer: 3,
+				lYpoI2: 11
+			}],
+			9: [function(c, d, e) {
+				(function(e, t, n, r, u, s, a, f, l) {
+					function b(e, t) {
+						var n = (65535 & e) + (65535 & t);
+						return (e >> 16) + (t >> 16) + (n >> 16) << 16 | 65535 & n;
+					}
+					function o(e, l) {
+						var c, d = new Array(1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298), t = new Array(1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225), n = new Array(64);
+						e[l >> 5] |= 128 << 24 - l % 32, e[15 + (l + 64 >> 9 << 4)] = l;
+						for (var r, o, h = 0; h < e.length; h += 16) {
+							for (var i = t[0], u = t[1], s = t[2], p = t[3], a = t[4], g = t[5], y = t[6], w = t[7], f = 0; f < 64; f++) n[f] = f < 16 ? e[f + h] : b(b(b((o = n[f - 2], m(o, 17) ^ m(o, 19) ^ v(o, 10)), n[f - 7]), (o = n[f - 15], m(o, 7) ^ m(o, 18) ^ v(o, 3))), n[f - 16]), c = b(b(b(b(w, m(o = a, 6) ^ m(o, 11) ^ m(o, 25)), a & g ^ ~a & y), d[f]), n[f]), r = b(m(r = i, 2) ^ m(r, 13) ^ m(r, 22), i & u ^ i & s ^ u & s), w = y, y = g, g = a, a = b(p, c), p = s, s = u, u = i, i = b(c, r);
+							t[0] = b(i, t[0]), t[1] = b(u, t[1]), t[2] = b(s, t[2]), t[3] = b(p, t[3]), t[4] = b(a, t[4]), t[5] = b(g, t[5]), t[6] = b(y, t[6]), t[7] = b(w, t[7]);
+						}
+						return t;
+					}
+					var i = c("./helpers"), m = function(e, t) {
+						return e >>> t | e << 32 - t;
+					}, v = function(e, t) {
+						return e >>> t;
+					};
+					d.exports = function(e) {
+						return i.hash(e, o, 32, !0);
+					};
+				}).call(this, c("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, c("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/crypto-browserify/sha256.js", "/node_modules/gulp-browserify/node_modules/crypto-browserify");
+			}, {
+				"./helpers": 4,
+				buffer: 3,
+				lYpoI2: 11
+			}],
+			10: [function(e, t, f) {
+				(function(e, t, n, r, o, i, u, s, a) {
+					f.read = function(e, t, n, r, o) {
+						var i, u, l = 8 * o - r - 1, c = (1 << l) - 1, d = c >> 1, s = -7, a = n ? o - 1 : 0, f = n ? -1 : 1, o = e[t + a];
+						for (a += f, i = o & (1 << -s) - 1, o >>= -s, s += l; 0 < s; i = 256 * i + e[t + a], a += f, s -= 8);
+						for (u = i & (1 << -s) - 1, i >>= -s, s += r; 0 < s; u = 256 * u + e[t + a], a += f, s -= 8);
+						if (0 === i) i = 1 - d;
+						else {
+							if (i === c) return u ? NaN : Infinity * (o ? -1 : 1);
+							u += Math.pow(2, r), i -= d;
+						}
+						return (o ? -1 : 1) * u * Math.pow(2, i - r);
+					}, f.write = function(e, t, l, n, r, c) {
+						var o, i, u = 8 * c - r - 1, s = (1 << u) - 1, a = s >> 1, d = 23 === r ? Math.pow(2, -24) - Math.pow(2, -77) : 0, f = n ? 0 : c - 1, h = n ? 1 : -1, c = t < 0 || 0 === t && 1 / t < 0 ? 1 : 0;
+						for (t = Math.abs(t), isNaN(t) || t === Infinity ? (i = isNaN(t) ? 1 : 0, o = s) : (o = Math.floor(Math.log(t) / Math.LN2), t * (n = Math.pow(2, -o)) < 1 && (o--, n *= 2), 2 <= (t += 1 <= o + a ? d / n : d * Math.pow(2, 1 - a)) * n && (o++, n /= 2), s <= o + a ? (i = 0, o = s) : 1 <= o + a ? (i = (t * n - 1) * Math.pow(2, r), o += a) : (i = t * Math.pow(2, a - 1) * Math.pow(2, r), o = 0)); 8 <= r; e[l + f] = 255 & i, f += h, i /= 256, r -= 8);
+						for (o = o << r | i, u += r; 0 < u; e[l + f] = 255 & o, f += h, o /= 256, u -= 8);
+						e[l + f - h] |= 128 * c;
+					};
+				}).call(this, e("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, e("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/ieee754/index.js", "/node_modules/gulp-browserify/node_modules/ieee754");
+			}, {
+				buffer: 3,
+				lYpoI2: 11
+			}],
+			11: [function(e, h, t) {
+				(function(e, t, n, r, o, f, l, c, d) {
+					var i, u, s;
+					function a() {}
+					(e = h.exports = {}).nextTick = (u = "undefined" != typeof window && window.setImmediate, s = "undefined" != typeof window && window.postMessage && window.addEventListener, u ? function(e) {
+						return window.setImmediate(e);
+					} : s ? (i = [], window.addEventListener("message", function(e) {
+						var t = e.source;
+						t !== window && null !== t || "process-tick" !== e.data || (e.stopPropagation(), 0 < i.length && i.shift()());
+					}, !0), function(e) {
+						i.push(e), window.postMessage("process-tick", "*");
+					}) : function(e) {
+						setTimeout(e, 0);
+					}), e.title = "browser", e.browser = !0, e.env = {}, e.argv = [], e.on = a, e.addListener = a, e.once = a, e.off = a, e.removeListener = a, e.removeAllListeners = a, e.emit = a, e.binding = function(e) {
+						throw new Error("process.binding is not supported");
+					}, e.cwd = function() {
+						return "/";
+					}, e.chdir = function(e) {
+						throw new Error("process.chdir is not supported");
+					};
+				}).call(this, e("lYpoI2"), "undefined" != typeof self ? self : "undefined" != typeof window ? window : {}, e("buffer").Buffer, arguments[3], arguments[4], arguments[5], arguments[6], "/node_modules/gulp-browserify/node_modules/process/browser.js", "/node_modules/gulp-browserify/node_modules/process");
+			}, {
+				buffer: 3,
+				lYpoI2: 11
+			}]
+		}, {}, [1])(1);
+	});
+})))();
+/**
+* Deep clone a value, preserving function references and class instances.
+* Unlike structuredClone, this handles objects that contain functions
+* (e.g. CollectionConfig with target(), childCollections(), callbacks).
+*/
+function deepClone(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value === "function") return value;
+	if (typeof value !== "object") return value;
+	if (Array.isArray(value)) return value.map((item) => deepClone(item));
+	if (Object.getPrototypeOf(value) !== Object.prototype) return value;
+	const result = {};
+	for (const key of Object.keys(value)) result[key] = deepClone(value[key]);
+	return result;
+}
+function isObject(item) {
+	return !!item && typeof item === "object" && !Array.isArray(item);
+}
+function isPlainObject(obj) {
+	if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return false;
+	return Object.getPrototypeOf(obj) === Object.prototype;
+}
+function mergeDeep(target, source, ignoreUndefined = false) {
+	if (!isObject(target)) return target;
+	const output = { ...target };
+	if (!isObject(source)) return output;
+	for (const key in source) {
+		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+		if (Object.prototype.hasOwnProperty.call(source, key)) {
+			const sourceValue = source[key];
+			const outputValue = output[key];
+			if (ignoreUndefined && sourceValue === void 0) continue;
+			if (sourceValue instanceof Date) output[key] = new Date(sourceValue.getTime());
+			else if (Array.isArray(sourceValue)) if (Array.isArray(outputValue)) if (!(sourceValue.some(isPlainObject) || outputValue.some(isPlainObject))) output[key] = [...sourceValue];
+			else {
+				const newArray = [];
+				const maxLength = Math.max(outputValue.length, sourceValue.length);
+				for (let i = 0; i < maxLength; i++) {
+					const sourceItem = sourceValue[i];
+					const targetItem = outputValue[i];
+					if (i >= sourceValue.length) newArray[i] = targetItem;
+					else if (i >= outputValue.length) newArray[i] = sourceItem;
+					else if (sourceItem === null) newArray[i] = targetItem;
+					else if (isPlainObject(sourceItem) && isPlainObject(targetItem)) newArray[i] = mergeDeep(targetItem, sourceItem, ignoreUndefined);
+					else newArray[i] = sourceItem;
+				}
+				output[key] = newArray;
+			}
+			else output[key] = [...sourceValue];
+			else if (isPlainObject(sourceValue)) if (isPlainObject(outputValue)) output[key] = mergeDeep(outputValue, sourceValue, ignoreUndefined);
+			else output[key] = sourceValue;
+			else if (isObject(sourceValue)) output[key] = sourceValue;
+			else output[key] = sourceValue;
+		}
+	}
+	return output;
+}
+function removeFunctions(o) {
+	if (o === void 0) return void 0;
+	if (o === null) return null;
+	if (typeof o === "object") {
+		if (Array.isArray(o)) return o.map((v) => removeFunctions(v));
+		if (!isPlainObject(o)) return o;
+		return Object.entries(o).filter(([_, value]) => typeof value !== "function").map(([key, value]) => {
+			if (Array.isArray(value)) return { [key]: value.map((v) => removeFunctions(v)) };
+			else if (typeof value === "object") return { [key]: removeFunctions(value) };
+			else return { [key]: value };
+		}).reduce((a, b) => ({
+			...a,
+			...b
+		}), {});
+	}
+	return o;
+}
+//#endregion
+//#region ../utils/src/sha1.ts
+/**
+* Minimal SHA-1 implementation that runs in both Node and the browser.
+*
+* This exists because generated Postgres policy names embed a SHA-1 digest of
+* the security rule. The DDL generator runs on the server (where `node:crypto`
+* is available) but the Studio has to derive the same names in the browser to
+* tell a policy it generated apart from one it did not. `node:crypto` cannot be
+* bundled for the browser, so the shared derivation needs a portable digest.
+*
+* SHA-1 is used purely to name things deterministically — never for security.
+* The output is byte-identical to `createHash("sha1").update(str).digest("hex")`,
+* which `sha1.test.ts` pins against `node:crypto` directly.
+*/
+/** Rotate a 32-bit word left by `n` bits. */
+function rotl(value, n) {
+	return value << n | value >>> 32 - n;
+}
+/**
+* SHA-1 digest of a string, hex-encoded.
+*
+* The input is encoded as UTF-8, matching Node's default handling of strings
+* passed to `hash.update(str)`.
+*/
+function sha1Hex(input) {
+	const bytes = Array.from(new TextEncoder().encode(input));
+	const bitLength = bytes.length * 8;
+	bytes.push(128);
+	while (bytes.length % 64 !== 56) bytes.push(0);
+	const hi = Math.floor(bitLength / 4294967296);
+	const lo = bitLength >>> 0;
+	bytes.push(hi >>> 24 & 255, hi >>> 16 & 255, hi >>> 8 & 255, hi & 255);
+	bytes.push(lo >>> 24 & 255, lo >>> 16 & 255, lo >>> 8 & 255, lo & 255);
+	let h0 = 1732584193;
+	let h1 = 4023233417;
+	let h2 = 2562383102;
+	let h3 = 271733878;
+	let h4 = 3285377520;
+	const w = new Array(80);
+	for (let offset = 0; offset < bytes.length; offset += 64) {
+		for (let i = 0; i < 16; i++) {
+			const j = offset + i * 4;
+			w[i] = bytes[j] << 24 | bytes[j + 1] << 16 | bytes[j + 2] << 8 | bytes[j + 3] | 0;
+		}
+		for (let i = 16; i < 80; i++) w[i] = rotl(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
+		let a = h0;
+		let b = h1;
+		let c = h2;
+		let d = h3;
+		let e = h4;
+		for (let i = 0; i < 80; i++) {
+			let f;
+			let k;
+			if (i < 20) {
+				f = b & c | ~b & d;
+				k = 1518500249;
+			} else if (i < 40) {
+				f = b ^ c ^ d;
+				k = 1859775393;
+			} else if (i < 60) {
+				f = b & c | b & d | c & d;
+				k = 2400959708;
+			} else {
+				f = b ^ c ^ d;
+				k = 3395469782;
+			}
+			const temp = rotl(a, 5) + f + e + k + w[i] | 0;
+			e = d;
+			d = c;
+			c = rotl(b, 30);
+			b = a;
+			a = temp;
+		}
+		h0 = h0 + a | 0;
+		h1 = h1 + b | 0;
+		h2 = h2 + c | 0;
+		h3 = h3 + d | 0;
+		h4 = h4 + e | 0;
+	}
+	return [
+		h0,
+		h1,
+		h2,
+		h3,
+		h4
+	].map((word) => (word >>> 0).toString(16).padStart(8, "0")).join("");
+}
+//#endregion
+//#region ../utils/src/policy-names.ts
+/**
+* Naming of the Postgres policies generated from a collection's security rules.
+*
+* A rule without an explicit `name` is compiled to `<table>_<op>_<hash>`, where
+* the hash covers the rule's semantics. The Studio needs the same names to tell
+* "this policy came from your code" apart from "someone wrote this in SQL" —
+* without them it treats generated policies as foreign and offers to import
+* them back into the codebase they came from.
+*
+* This is the single definition of that naming. The DDL and Drizzle generators
+* both derive names from here, so a change cannot silently rename every policy
+* in every deployed database while the UI keeps matching the old ones.
+*/
+/** Stable digest of the parts of a rule that determine what the policy does. */
+function getPolicyNameHash(rule) {
+	return sha1Hex(JSON.stringify({
+		a: rule.access,
+		m: rule.mode,
+		op: rule.operation,
+		ops: rule.operations?.slice().sort(),
+		own: rule.ownerField,
+		rol: rule.roles?.slice().sort(),
+		pg: rule.pgRoles?.slice().sort(),
+		u: rule.using,
+		w: rule.withCheck,
+		c: rule.condition,
+		ch: rule.check
+	})).substring(0, 7);
+}
+/** The operations a rule expands to — `operations` wins over `operation`. */
+function getPolicyOperations(rule) {
+	return rule.operations && rule.operations.length > 0 ? rule.operations : [rule.operation ?? "all"];
+}
+/**
+* Every Postgres policy name a single rule compiles to — one per operation.
+*
+* @param rule      The security rule as written in the collection config.
+* @param tableName The rule's table (see `getTableName` in `@rebasepro/common`).
+*/
+function getPolicyNamesForRule(rule, tableName) {
+	const ops = getPolicyOperations(rule);
+	const ruleHash = getPolicyNameHash(rule);
+	return ops.map((op, opIdx) => rule.name ? ops.length > 1 ? `${rule.name}_${op}` : rule.name : `${tableName}_${op}_${ruleHash}${ops.length > 1 ? `_${opIdx}` : ""}`);
+}
+//#endregion
+//#region ../utils/src/names.ts
+/**
+* Generates a foreign key column name from a given string, typically a collection slug or name.
+* It converts the name to snake_case, attempts to singularize it by removing a trailing 's'
+* (a common convention for collection names), and appends '_id'.
+*
+* @param name The base name to convert to a foreign key.
+* @returns A foreign key name in the format 'singular_name_id'.
+*
+* @example
+* // returns "user_id"
+* generateForeignKeyName("users")
+*
+* @example
+* // returns "post_id"
+* generateForeignKeyName("posts")
+*
+* @example
+* // returns "product_id"
+* generateForeignKeyName("Product")
+*
+*/
+function generateForeignKeyName(name) {
+	const snakeCaseName = toSnakeCase(name);
+	return `${snakeCaseName.endsWith("s") ? snakeCaseName.slice(0, -1) : snakeCaseName}_id`;
+}
+//#endregion
+//#region ../common/src/util/entities.ts
+/**
+* Update the automatic values in a entity before save
+* @group Driver
+*/
+function updateDateAutoValues({ inputValues, properties, status, timestampNowValue }) {
+	return traverseValuesProperties(inputValues, properties, (inputValue, property) => {
+		if (property.type === "date") if (status === "existing" && property.autoValue === "on_update") return timestampNowValue;
+		else if ((status === "new" || status === "copy") && (property.autoValue === "on_update" || property.autoValue === "on_create")) return timestampNowValue;
+		else return inputValue;
+		else return inputValue;
+	}) ?? {};
+}
+/**
+* Normalize a value into a proper EntityRelation instance.
+* Handles EntityRelation class instances, and plain objects
+* with `__type === "relation"` or an `isEntityRelation()` method.
+*
+* When `propertyType` is `"relation"`, also accepts plain objects that
+* have `id` and `path` fields — these are relation-shaped objects from
+* edge cases in the data pipeline (REST fallback, stale cache, custom data source).
+*
+* Returns null if the value cannot be coerced.
+*/
+function normalizeToEntityRelation(value, propertyType) {
+	if (value instanceof EntityRelation) return value;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const obj = value;
+	if (!(obj.__type === "relation" || obj.__type === "reference" || typeof obj.isEntityRelation === "function" && obj.isEntityRelation() || typeof obj.isEntityReference === "function" && obj.isEntityReference() || propertyType === "relation" && typeof obj.id !== "undefined" && typeof obj.path === "string")) return null;
+	return new EntityRelation(obj.id, obj.path, obj.data);
+}
+function traverseValuesProperties(inputValues, properties, operation) {
+	const safeInputValues = inputValues ?? {};
+	const result = mergeDeep(safeInputValues, Object.entries(properties).map(([key, property]) => {
+		const updatedValue = traverseValueProperty(safeInputValues && safeInputValues[key], property, operation);
+		if (updatedValue === null) return null;
+		if (updatedValue === void 0) return void 0;
+		return { [key]: updatedValue };
+	}).reduce((a, b) => ({
+		...a,
+		...b
+	}), {}));
+	if (!result || Object.keys(result).length === 0) return void 0;
+	return result;
+}
+function traverseValueProperty(inputValue, property, operation) {
+	let value;
+	if (property.type === "map" && property.properties) value = traverseValuesProperties(inputValue, property.properties, operation);
+	else if (property.type === "array") {
+		const of = property.of;
+		if (of && Array.isArray(inputValue) && !Array.isArray(of)) value = inputValue.map((e) => traverseValueProperty(e, of, operation));
+		else if (of && Array.isArray(inputValue) && Array.isArray(of)) value = inputValue.map((e, i) => {
+			if (i < of.length) return traverseValueProperty(e, of[i], operation);
+			return null;
+		}).filter(Boolean);
+		else if (property.oneOf && Array.isArray(inputValue)) {
+			const typeField = property.oneOf?.typeField ?? "type";
+			const valueField = property.oneOf?.valueField ?? "value";
+			value = inputValue.map((e) => {
+				if (e === null) return null;
+				if (typeof e !== "object") return e;
+				const rec = e;
+				const type = rec[typeField];
+				const childProperty = property.oneOf?.properties[type];
+				if (!type || !childProperty) return e;
+				return {
+					[typeField]: type,
+					[valueField]: traverseValueProperty(rec[valueField], childProperty, operation)
+				};
+			});
+		} else value = inputValue;
+	} else value = operation(inputValue, property);
+	return value;
+}
+/**
+* Create a lightweight relation stub for CMS views.
+* Replaces inline `{ id, path, __type: "relation" }` object literals.
+*/
+function createRelationRef(id, path) {
+	return {
+		id,
+		path,
+		__type: "relation"
+	};
+}
+/**
+* Create a hydrated relation reference that includes the full entity data.
+* Used when entity data has been pre-fetched (e.g., via batch loading or JOINs).
+*/
+function createRelationRefWithData(id, path, data) {
+	return {
+		id,
+		path,
+		__type: "relation",
+		data
+	};
+}
+/**
+* Derive a row's address from its key columns.
+*
+* Single key → the value as a string. Composite → each part joined by
+* {@link COMPOSITE_ID_SEPARATOR}, in primary-key order, which is what
+* {@link parseIdValues} expects to invert.
+*/
+function buildCompositeId(values, primaryKeys) {
+	if (primaryKeys.length === 0) return "";
+	if (primaryKeys.length === 1) return String(values[primaryKeys[0].fieldName] ?? "");
+	return primaryKeys.map((pk) => String(values[pk.fieldName] ?? "")).join(":::");
+}
+/**
+* Invert {@link buildCompositeId}: turn an address back into key columns, each
+* coerced to the type its column actually round-trips as.
+*
+* This is the boundary where a URL segment becomes a query parameter, so a
+* malformed address must throw rather than silently produce a query that
+* matches the wrong row (or none).
+*/
+function parseIdValues(idValue, primaryKeys) {
+	const result = {};
+	if (primaryKeys.length === 0) return result;
+	if (primaryKeys.length === 1) {
+		const pk = primaryKeys[0];
+		if (pk.type === "number" && !pk.isUUID) {
+			const parsed = typeof idValue === "number" ? idValue : parseInt(String(idValue), 10);
+			if (isNaN(parsed)) throw new Error(`Invalid numeric ID: ${idValue}`);
+			result[pk.fieldName] = parsed;
+		} else result[pk.fieldName] = String(idValue);
+		return result;
+	}
+	const parts = String(idValue).split(":::");
+	if (parts.length !== primaryKeys.length) throw new Error(`Composite ID parts mismatch. Expected ${primaryKeys.length}, got ${parts.length} for ID: ${idValue}`);
+	for (let i = 0; i < primaryKeys.length; i++) {
+		const pk = primaryKeys[i];
+		const val = parts[i];
+		if (pk.type === "number" && !pk.isUUID) {
+			const parsed = parseInt(val, 10);
+			if (isNaN(parsed)) throw new Error(`Invalid numeric ID component: ${val}`);
+			result[pk.fieldName] = parsed;
+		} else result[pk.fieldName] = val;
+	}
+	return result;
+}
+/**
+* The primary keys of a collection, as declared by its properties.
+*
+* This is the only tier both sides can read, because it is the only one written
+* in the config: the postgres driver can also infer keys from the Drizzle
+* schema, which the browser never sees and is never sent — the admin compiles
+* the collection files into its own bundle rather than being served them. A key
+* that lives only in the Drizzle schema is therefore invisible here, and the
+* server says so at boot (`warnOnKeysTheAdminCannotResolve`) naming the `isId`
+* to add.
+*
+* Returns an empty array when a collection declares none, which callers must
+* treat as "not addressable" rather than defaulting to `id`: guessing a key
+* that is not the real one produces confidently wrong addresses.
+*/
+function getDeclaredPrimaryKeys(collection) {
+	const properties = collection.properties;
+	if (!properties) return [];
+	const keys = [];
+	for (const [fieldName, propRaw] of Object.entries(properties)) {
+		const prop = propRaw;
+		if (!prop || typeof prop !== "object") continue;
+		if (!("isId" in prop) || !prop.isId) continue;
+		keys.push({
+			fieldName,
+			type: prop.type === "number" ? "number" : "string",
+			isUUID: prop.isId === "uuid"
+		});
+	}
+	return keys;
+}
+/**
+* The keys to address a collection's rows with, resolved the way the driver
+* resolves them — minus the tier the browser cannot reach.
+*
+* The postgres driver tries, in order: properties marked `isId`; the primary
+* keys of the Drizzle schema; and finally a column literally named `id`. Only
+* the first and last are visible in a `CollectionConfig`, which is what both
+* sides share.
+*
+* So the two agree except on a collection that declares no `isId` and whose key
+* is known only to Drizzle. There, the driver reads the real key, and this
+* either resolves nothing (reported to the console by the caller) or — if the
+* table happens to have an unrelated `id` property — resolves `id`, which is
+* the wrong key and cannot be detected from here: the addresses look right and
+* route wrong. Only the config can settle it, so the server names both cases
+* at boot (`warnOnKeysTheAdminCannotResolve`) with the `isId` to add.
+*/
+function resolvePrimaryKeys(collection) {
+	const declared = getDeclaredPrimaryKeys(collection);
+	if (declared.length > 0) return declared;
+	const idProp = collection.properties?.id;
+	if (idProp && typeof idProp === "object") return [{
+		fieldName: "id",
+		type: idProp.type === "number" ? "number" : "string"
+	}];
+	return [];
+}
+//#endregion
+//#region ../common/src/util/enums.ts
+function enumToObjectEntries(enumValues) {
+	if (Array.isArray(enumValues)) return enumValues;
+	else return Object.entries(enumValues).map(([id, value]) => {
+		if (typeof value === "string") return {
+			id,
+			label: value
+		};
+		else return {
+			...value,
+			id
+		};
+	});
+}
+//#endregion
+//#region ../common/src/util/relations.ts
+function sanitizeRelation(relation, sourceCollection, resolveCollection) {
+	if (!relation.target) throw new Error("Relation is missing a `target` collection.");
+	const rawTarget = relation.target;
+	let targetCollection;
+	if (typeof rawTarget === "string") {
+		if (resolveCollection) targetCollection = resolveCollection(rawTarget);
+		if (!targetCollection) targetCollection = {
+			slug: rawTarget,
+			name: rawTarget
+		};
+	} else if (typeof rawTarget === "function") {
+		const evaluated = rawTarget();
+		if (typeof evaluated === "string") {
+			if (resolveCollection) targetCollection = resolveCollection(evaluated);
+			if (!targetCollection) targetCollection = {
+				slug: evaluated,
+				name: evaluated
+			};
+		} else targetCollection = evaluated;
+	} else if (rawTarget && typeof rawTarget === "object") targetCollection = rawTarget;
+	if (!targetCollection) throw new Error("Relation is missing a valid `target` collection.");
+	const newRelation = { ...relation };
+	newRelation.target = () => {
+		if (typeof rawTarget === "string") return resolveCollection && resolveCollection(rawTarget) || targetCollection;
+		else if (typeof rawTarget === "function") {
+			const evaluated = rawTarget();
+			if (typeof evaluated === "string") return resolveCollection && resolveCollection(evaluated) || targetCollection;
+			return evaluated;
+		}
+		return targetCollection;
+	};
+	if (!newRelation.relationName) newRelation.relationName = toSnakeCase(targetCollection.slug);
+	if (!newRelation.direction) if (newRelation.foreignKeyOnTarget) newRelation.direction = "inverse";
+	else if (newRelation.through) newRelation.direction = "owning";
+	else if (newRelation.cardinality === "many") newRelation.direction = "inverse";
+	else newRelation.direction = "owning";
+	if (!newRelation.joinPath) {
+		const sourceName = toSnakeCase(sourceCollection.slug ?? sourceCollection.name);
+		if (newRelation.cardinality === "one" && newRelation.direction === "owning") {
+			if (!newRelation.localKey) newRelation.localKey = generateForeignKeyName(newRelation.relationName);
+		} else if (newRelation.cardinality === "one" && newRelation.direction === "inverse") {
+			if (!newRelation.foreignKeyOnTarget) {
+				let foundForeignKey = false;
+				try {
+					const targetRelations = getDataSourceCapabilities(targetCollection.engine).supportsRelations ? targetCollection.relations || [] : [];
+					for (const targetRel of targetRelations) if (targetRel.direction === "owning" && targetRel.cardinality === "one" && targetRel.localKey) try {
+						if (targetRel.target().slug === sourceCollection.slug) {
+							newRelation.foreignKeyOnTarget = targetRel.localKey;
+							foundForeignKey = true;
+							break;
+						}
+					} catch (e) {
+						continue;
+					}
+				} catch (e) {}
+				if (!foundForeignKey) newRelation.foreignKeyOnTarget = generateForeignKeyName(newRelation.inverseRelationName ? toSnakeCase(newRelation.inverseRelationName) : sourceName);
+			}
+		} else if (newRelation.cardinality === "many" && newRelation.direction === "inverse") {
+			let isManyToManyInverse = false;
+			if (newRelation.inverseRelationName && !newRelation.foreignKeyOnTarget) try {
+				const targetRelations = getDataSourceCapabilities(targetCollection.engine).supportsRelations ? targetCollection.relations || [] : [];
+				for (const targetRel of targetRelations) if (targetRel.cardinality === "many" && (targetRel.direction === "owning" || !targetRel.direction) && targetRel.relationName === newRelation.inverseRelationName) {
+					isManyToManyInverse = true;
+					break;
+				}
+				if (!isManyToManyInverse && targetCollection.properties) for (const [propKey, prop] of Object.entries(targetCollection.properties)) {
+					if (prop.type !== "relation") continue;
+					const relProp = prop;
+					if ((relProp.relationName || propKey) === newRelation.inverseRelationName && relProp.cardinality === "many" && (relProp.direction === "owning" || !relProp.direction)) {
+						isManyToManyInverse = true;
+						break;
+					}
+				}
+			} catch (e) {}
+			if (!isManyToManyInverse && !newRelation.foreignKeyOnTarget) newRelation.foreignKeyOnTarget = generateForeignKeyName(sourceName);
+		} else if (newRelation.cardinality === "many" && newRelation.direction === "owning") {
+			const sourceTableName = getTableName(sourceCollection);
+			const targetTableName = getTableName(targetCollection);
+			newRelation.through = {
+				table: newRelation.through?.table ?? [sourceTableName, targetTableName].sort().join("_"),
+				sourceColumn: newRelation.through?.sourceColumn ?? generateForeignKeyName(sourceName),
+				targetColumn: newRelation.through?.targetColumn ?? generateForeignKeyName(newRelation.relationName)
+			};
+		}
+	}
+	if (newRelation.cardinality === "one" && newRelation.direction === "owning" && !newRelation.localKey && !newRelation.joinPath) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'owning' one-to-one relation requires a 'localKey'. Check the relation config for '${newRelation.relationName}'`);
+	if (newRelation.cardinality === "one" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-one relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
+	if (newRelation.cardinality === "many" && newRelation.direction === "inverse" && !newRelation.foreignKeyOnTarget && !newRelation.joinPath && !newRelation.inverseRelationName) throw new Error(`Configuration Error in relation from '${sourceCollection.name}': An 'inverse' one-to-many relation requires a 'foreignKeyOnTarget'. Check the relation config for '${newRelation.relationName}'`);
+	return newRelation;
+}
+/** WeakMap cache — same collection instance always yields the same relation map. */
+var _resolvedRelationsCache = /* @__PURE__ */ new WeakMap();
+function resolveCollectionRelations(collection) {
+	const cached = _resolvedRelationsCache.get(collection);
+	if (cached) return cached;
+	if (!getDataSourceCapabilities(collection.engine).supportsRelations) return {};
+	const relations = {};
+	const registeredRelationNames = /* @__PURE__ */ new Set();
+	if (collection.relations) collection.relations.forEach((relation) => {
+		try {
+			const normalizedRelation = sanitizeRelation(relation, collection);
+			const relationKey = normalizedRelation.relationName;
+			if (relationKey) {
+				relations[relationKey] = normalizedRelation;
+				registeredRelationNames.add(relationKey);
+			}
+		} catch (e) {}
+	});
+	if (collection.properties) Object.entries(collection.properties).forEach(([propKey, prop]) => {
+		const relation = resolvePropertyRelation({
+			propertyKey: propKey,
+			property: prop,
+			sourceCollection: collection
+		});
+		if (relation) {
+			if (relations[propKey]) return;
+			if (!relation.relationName) relation.relationName = propKey;
+			const normalizedRelation = sanitizeRelation(relation, collection);
+			relations[propKey] = normalizedRelation;
+			registeredRelationNames.add(normalizedRelation.relationName ?? propKey);
+		}
+	});
+	_resolvedRelationsCache.set(collection, relations);
+	return relations;
+}
+function resolvePropertyRelation({ propertyKey, property, sourceCollection }) {
+	if (property.type !== "relation") return void 0;
+	const relProp = property;
+	if (relProp.target) return {
+		relationName: relProp.relationName || propertyKey,
+		target: relProp.target,
+		cardinality: relProp.cardinality || "one",
+		direction: relProp.direction || "owning",
+		inverseRelationName: relProp.inverseRelationName,
+		localKey: relProp.localKey,
+		foreignKeyOnTarget: relProp.foreignKeyOnTarget,
+		through: relProp.through,
+		joinPath: relProp.joinPath,
+		onUpdate: relProp.onUpdate,
+		onDelete: relProp.onDelete,
+		overrides: relProp.overrides
+	};
+	console.warn(`Unrecognized or missing relation target for property '${propertyKey}' in collection '${sourceCollection.slug}'`);
+}
+function getTableName(collection) {
+	if (getDataSourceCapabilities(collection.engine).supportsRelations) return collection.table ?? toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+	return toSnakeCase(collection.slug) ?? toSnakeCase(collection.name);
+}
+function getTableVarName(tableName) {
+	return tableName.replace(/_([a-z])/g, (_, char) => char.toUpperCase());
+}
+function getEnumVarName(tableName, propName) {
+	return `${getTableVarName(tableName)}${propName.charAt(0).toUpperCase() + propName.slice(1)}`;
+}
+function getColumnName(fullColumn) {
+	return fullColumn.includes(".") ? fullColumn.split(".").pop() : fullColumn;
+}
+/**
+* Look up a relation by key with forgiving normalization.
+*
+* `resolveCollectionRelations` stores each relation under a single canonical
+* key (no aliases). This helper tries the given key as-is, then falls back to
+* slug form (underscores → hyphens) and snake_case form (hyphens → underscores)
+* so that callers that receive a key from external input (URL path segments,
+* user-provided config, etc.) can still find the right entry.
+*/
+function findRelation(resolvedRelations, key) {
+	if (resolvedRelations[key]) return resolvedRelations[key];
+	const slugKey = key.replace(/_/g, "-");
+	if (slugKey !== key && resolvedRelations[slugKey]) return resolvedRelations[slugKey];
+	const snakeKey = key.replace(/-/g, "_");
+	if (snakeKey !== key && resolvedRelations[snakeKey]) return resolvedRelations[snakeKey];
+}
+//#endregion
+//#region ../common/src/util/resolutions.ts
+function getSubcollections(collection) {
+	if (collection.childCollections) return collection.childCollections() ?? [];
+	const declaredSubcollections = getDeclaredSubcollections(collection);
+	if (getDataSourceCapabilities(collection.engine).supportsSubcollections && declaredSubcollections) return declaredSubcollections() ?? [];
+	if (getDataSourceCapabilities(collection.engine).supportsRelations) {
+		const resolvedRelations = resolveCollectionRelations(collection);
+		return Object.values(resolvedRelations).filter((r) => r.cardinality === "many").map((r) => {
+			const target = r.target();
+			if (!target) return void 0;
+			const relationKey = r.relationName || target.slug;
+			let customName;
+			if (collection.properties) {
+				const prop = Object.entries(collection.properties).find(([_, p]) => p.type === "relation" && p.relationName === relationKey);
+				if (prop && prop[1].name) customName = prop[1].name;
+			}
+			const baseOverrides = { slug: relationKey };
+			if (customName) {
+				baseOverrides.name = customName;
+				baseOverrides.singularName = customName;
+			}
+			const targetWithOverrides = {
+				...target,
+				...baseOverrides
+			};
+			return r.overrides ? mergeDeep(targetWithOverrides, r.overrides) : targetWithOverrides;
+		}).filter((c) => Boolean(c));
+	}
+	return [];
+}
+//#endregion
+//#region ../common/src/util/policy/sqlToPolicy.ts
+/**
+* A tiny, regex-based SQL "parser" for security rules.
+*
+* This is NOT a full SQL parser. It is designed to handle the subset of SQL
+* commonly used in `USING` and `WITH CHECK` clauses, enough to drive the
+* optimistic client-side UI decision.
+*
+* It handles:
+* - `field = 'literal'`
+* - `field != 'literal'`
+* - `field = current_setting('app.uid')` (or the legacy `app.user_id`)
+* - `A AND B`, `A OR B` — only where the keyword is at the top level
+* - `true`
+* - `IN (...)` (as optimistic true)
+*
+* For anything it doesn't understand, it returns a `raw` expression, which
+* the evaluator treats as "unknown" (and usually optimistic true).
+*
+* **This output also round-trips back into DDL** via `policyToPostgres` (the
+* schema/policy generators), so decomposing a clause the parser only partly
+* understands is not a cosmetic mistake — it emits invalid SQL. When in doubt,
+* prefer `raw`: it is reproduced verbatim.
+*/
+/** True when `keyword` starts at `i` as a standalone word. */
+function isKeywordAt(upper, i, keyword) {
+	if (!upper.startsWith(keyword, i)) return false;
+	const before = i === 0 ? " " : upper[i - 1];
+	const after = upper[i + keyword.length] ?? " ";
+	return /[\s()]/.test(before) && /[\s()]/.test(after);
+}
+/**
+* Split `sql` on a boolean keyword, but only where it sits at paren depth 0 and
+* outside a string literal. Returns null when it never does, so the caller
+* leaves the clause alone.
+*
+* This used to be `sql.split(/ AND /i)`, which tore subqueries in half: the
+* `AND` inside
+*   `EXISTS (SELECT 1 FROM organization_members m WHERE m.org = t.org AND m.user_id = auth.uid())`
+* split the expression, and re-emitting the halves produced
+*   `(EXISTS (...) AND m.user_id = auth.uid())`
+* where `m` is no longer in scope — SQL that Postgres rejects outright with
+* "missing FROM-clause entry for table". Returning null instead keeps such a
+* clause as a `raw` expression, which round-trips verbatim.
+*/
+function splitTopLevel(sql, keyword) {
+	const upper = sql.toUpperCase();
+	const parts = [];
+	let depth = 0;
+	let inString = false;
+	let start = 0;
+	for (let i = 0; i < sql.length; i++) {
+		const ch = sql[i];
+		if (inString) {
+			if (ch === "'") if (sql[i + 1] === "'") i++;
+			else inString = false;
+			continue;
+		}
+		if (ch === "'") {
+			inString = true;
+			continue;
+		}
+		if (ch === "(") {
+			depth++;
+			continue;
+		}
+		if (ch === ")") {
+			depth--;
+			continue;
+		}
+		if (depth === 0 && isKeywordAt(upper, i, keyword)) {
+			parts.push(sql.slice(start, i));
+			i += keyword.length - 1;
+			start = i + 1;
+		}
+	}
+	if (parts.length === 0) return null;
+	parts.push(sql.slice(start));
+	const trimmedParts = parts.map((p) => p.trim()).filter((p) => p.length > 0);
+	return trimmedParts.length > 1 ? trimmedParts : null;
+}
+/** Drop redundant wrapping parens (`(a AND b)` → `a AND b`), never `(a) AND (b)`. */
+function stripOuterParens(sql) {
+	let s = sql.trim();
+	for (;;) {
+		if (!s.startsWith("(") || !s.endsWith(")")) return s;
+		let depth = 0;
+		let inString = false;
+		let wraps = true;
+		for (let i = 0; i < s.length; i++) {
+			const ch = s[i];
+			if (inString) {
+				if (ch === "'") if (s[i + 1] === "'") i++;
+				else inString = false;
+				continue;
+			}
+			if (ch === "'") {
+				inString = true;
+				continue;
+			}
+			if (ch === "(") depth++;
+			else if (ch === ")") {
+				depth--;
+				if (depth === 0 && i < s.length - 1) {
+					wraps = false;
+					break;
+				}
+			}
+		}
+		if (!wraps) return s;
+		s = s.slice(1, -1).trim();
+	}
+}
+function sqlToPolicy(sql) {
+	const trimmed = stripOuterParens(sql.trim());
+	if (trimmed.toLowerCase() === "true") return policy.true();
+	if (trimmed.toLowerCase() === "false") return policy.false();
+	const overlapMatch = trimmed.match(/^string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*&&\s*ARRAY\s*\[(.+)\]$/i);
+	if (overlapMatch) {
+		const roles = overlapMatch[1].split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
+		return policy.rolesOverlap(roles);
+	}
+	const containMatch = trimmed.match(/^string_to_array\s*\(\s*auth\.roles\(\)\s*,\s*','\s*\)\s*@>\s*ARRAY\s*\[(.+)\]$/i);
+	if (containMatch) {
+		const roles = containMatch[1].split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
+		return policy.rolesContain(roles);
+	}
+	const orParts = splitTopLevel(trimmed, "OR");
+	if (orParts) return policy.or(...orParts.map(sqlToPolicy));
+	const andParts = splitTopLevel(trimmed, "AND");
+	if (andParts) return policy.and(...andParts.map(sqlToPolicy));
+	const match = trimmed.match(/^(.+?)\s*(!?=)\s*(.+)$/);
+	if (match) {
+		const [, leftStr, op, rightStr] = match;
+		const left = parseOperand(leftStr.trim());
+		const right = parseOperand(rightStr.trim());
+		if (left && right) return policy.compare(left, op === "=" ? "eq" : "neq", right);
+	}
+	return policy.raw(sql);
+}
+/**
+* Literals from other BaaS platforms that people compare `auth.uid()` against
+* out of habit. Mirrors the driver's `FOREIGN_CONVENTION_ROLES` guard on
+* `pgRoles`, one surface over: the same muscle memory inside a `using:` string
+* is the more dangerous spelling, because it inverts a rule instead of
+* emptying a table.
+*/
+var FOREIGN_CONVENTION_UIDS = {
+	anon: "Supabase",
+	authenticated: "Supabase",
+	service_role: "Supabase"
+};
+/** `auth.uid() IS NOT NULL` in raw SQL, the clause that is always true. */
+var UID_NOT_NULL = /auth\.uid\(\)\s+IS\s+NOT\s+NULL/i;
+/**
+* Find clauses that read as "signed-in users only" but admit anonymous callers.
+*
+* Both spellings come from the same place — Supabase, where `auth.uid()` really
+* is NULL for an anonymous request. Rebase substitutes
+* {@link ANONYMOUS_USER_ID} instead (a blank id would read back as NULL, which
+* is how the trusted *server* context is recognised), so:
+*
+*  - `auth.uid() IS NOT NULL` is a tautology on the user path, and
+*  - `auth.uid() != 'anon'` compares against a string no caller ever has.
+*
+* Either one turns a lockdown into a full grant, and neither looks wrong. No
+* real user id is ever one of these literals, and a user-context request is
+* never NULL, so a match is always a mistake rather than a deliberate check.
+*
+* Structured expressions are checked too, not just parsed SQL: `policy.compare`
+* can spell the same mistake.
+*/
+function findAnonymousGrants(expr) {
+	const found = [];
+	const visit = (e) => {
+		switch (e.kind) {
+			case "and":
+			case "or":
+				e.operands.forEach(visit);
+				return;
+			case "not":
+				visit(e.operand);
+				return;
+			case "existsIn":
+				visit(e.where);
+				return;
+			case "raw":
+				if (UID_NOT_NULL.test(e.sql)) found.push({
+					pattern: "uid-not-null",
+					detail: e.sql,
+					explanation: `\`auth.uid() IS NOT NULL\` is true for every request that came from a client, including anonymous ones — they carry '${ANONYMOUS_USER_ID}', not NULL. Use \`condition: policy.authenticated()\` to mean "signed in".`
+				});
+				return;
+			case "compare": {
+				const literal = [e.left, e.right].find((o) => o.kind === "literal");
+				if (!(e.left.kind === "authUid" || e.right.kind === "authUid") || typeof literal?.value !== "string") return;
+				const platform = FOREIGN_CONVENTION_UIDS[literal.value];
+				if (!platform) return;
+				found.push({
+					pattern: "foreign-uid-literal",
+					detail: literal.value,
+					explanation: `'${literal.value}' is a ${platform} convention. Rebase reports an anonymous request as '${ANONYMOUS_USER_ID}', so comparing against '${literal.value}' passes for every caller. Use \`condition: policy.authenticated()\` to mean "signed in".`
+				});
+				return;
+			}
+			default: return;
+		}
+	};
+	visit(expr);
+	return found;
+}
+function parseOperand(str) {
+	if (/current_setting\s*\(\s*'app\.(uid|user_id)'\s*\)/i.test(str) || /auth\.uid\(\)/i.test(str)) return policy.authUid();
+	const stringMatch = str.match(/^'(.+)'$/);
+	if (stringMatch) return policy.literal(stringMatch[1]);
+	if (/^\w+$/.test(str)) return policy.field(str);
+	return null;
+}
+//#endregion
+//#region ../common/src/util/policy/securityRuleToConditions.ts
+/**
+* Desugars a {@link SecurityRule} — its `access`/`ownerField`/`roles` shortcuts,
+* structured `condition`/`check`, and raw `using`/`withCheck` — into a single
+* normalized {@link PolicyExpression} pair.
+*
+* **This is the linchpin against drift:** both the Postgres DDL generators and
+* the client-side evaluator consume this one function, so there is exactly one
+* definition of what a rule means. In particular, application `roles` are folded
+* into the expression here (AND'd with the base condition, matching how Postgres
+* generates the clause) rather than being handled separately by each consumer.
+*/
+function securityRuleToConditions(rule) {
+	return {
+		usingExpr: withRoles(baseUsing(rule), rule),
+		withCheckExpr: withRoles(baseWithCheck(rule), rule)
+	};
+}
+function baseUsing(rule) {
+	if (rule.condition) return rule.condition;
+	if (rule.using != null) return sqlToPolicy(rule.using);
+	if (rule.access === "public") return policy.true();
+	if (rule.ownerField) return policy.compare(policy.field(rule.ownerField), "eq", policy.authUid());
+	return null;
+}
+function baseWithCheck(rule) {
+	if (rule.check) return rule.check;
+	if (rule.withCheck != null) return sqlToPolicy(rule.withCheck);
+	return baseUsing(rule);
+}
+/**
+* AND the base condition with an application-role check, or produce a roles-only
+* condition when there is no base. Mirrors the Postgres generator so that a
+* role-scoped restrictive rule denies exactly the same set of users on both
+* sides.
+*/
+function withRoles(base, rule) {
+	if (!rule.roles || rule.roles.length === 0) return base;
+	const rolesExpr = policy.rolesOverlap(rule.roles);
+	if (rule.mode === "restrictive") return base ? policy.or(policy.not(rolesExpr), base) : policy.not(rolesExpr);
+	return base ? policy.and(base, rolesExpr) : rolesExpr;
+}
+//#endregion
+//#region ../common/src/util/policy/policyToPostgres.ts
+/**
+* Compiles a {@link PolicyExpression} to a PostgreSQL boolean SQL string,
+* suitable for a `USING (...)` / `WITH CHECK (...)` clause.
+*
+* This is one of the two consumers of the shared policy model (the other being
+* {@link evaluatePolicy}); the Postgres schema generators call it so that DDL
+* and the admin UI derive from the exact same expression.
+*/
+function policyToPostgres(expr, collection, options) {
+	return compile(expr, {
+		fieldCollection: collection,
+		fieldPrefix: "",
+		outerCollection: collection,
+		outerPrefix: "",
+		resolveCollection: options?.resolveCollection,
+		alias: { n: 0 }
+	});
+}
+function compile(expr, scope) {
+	switch (expr.kind) {
+		case "true": return "true";
+		case "false": return "false";
+		case "and": return expr.operands.length === 0 ? "true" : expr.operands.map((o) => `(${compile(o, scope)})`).join(" AND ");
+		case "or": return expr.operands.length === 0 ? "false" : expr.operands.map((o) => `(${compile(o, scope)})`).join(" OR ");
+		case "not": return `NOT (${compile(expr.operand, scope)})`;
+		case "compare": {
+			const castForAuthUid = (operand, sqlText, other) => other.kind === "authUid" && (operand.kind === "field" || operand.kind === "outerField") ? `(${sqlText})::text` : sqlText;
+			const leftSql = castForAuthUid(expr.left, operandToSql(expr.left, scope), expr.right);
+			const rightSql = castForAuthUid(expr.right, operandToSql(expr.right, scope), expr.left);
+			return `${leftSql} ${COMPARE_SQL[expr.op]} ${rightSql}`;
+		}
+		case "rolesOverlap": return `string_to_array(auth.roles(), ',') && ${rolesArraySql(expr.roles)}`;
+		case "rolesContain": return `string_to_array(auth.roles(), ',') @> ${rolesArraySql(expr.roles)}`;
+		case "authenticated": return `auth.uid() IS NOT NULL AND auth.uid() <> ${quoteLiteral(ANONYMOUS_USER_ID)}`;
+		case "serverContext": return "auth.uid() IS NULL";
+		case "existsIn": return compileExistsIn(expr, scope);
+		case "raw": return expr.sql.replace(/\{(\w+)\}/g, (_, col) => `${outerQualifier(scope)}${resolveColumnName(col, scope.outerCollection)}`);
+	}
+}
+/**
+* Compiles `existsIn` to a correlated `EXISTS (SELECT 1 FROM <join> WHERE ...)`.
+* Inside the subquery, `field` operands bind to the aliased join table and
+* `outerField` operands bind to the (table-qualified) outer RLS row.
+*/
+function compileExistsIn(expr, scope) {
+	const join = scope.resolveCollection?.(expr.collection);
+	const joinTable = join ? getTableName(join) : toSnakeCase(expr.collection);
+	const joinSchema = schemaOf(join) ?? schemaOf(scope.outerCollection) ?? "public";
+	const alias = `_ex${scope.alias.n++}`;
+	const outerPrefix = outerQualifier(scope);
+	const innerScope = {
+		fieldCollection: join,
+		fieldPrefix: `"${alias}".`,
+		outerCollection: scope.outerCollection,
+		outerPrefix,
+		resolveCollection: scope.resolveCollection,
+		alias: scope.alias
+	};
+	return `EXISTS (SELECT 1 FROM "${joinSchema}"."${joinTable}" "${alias}" WHERE ${compile(expr.where, innerScope)})`;
+}
+var COMPARE_SQL = {
+	eq: "=",
+	neq: "!=",
+	lt: "<",
+	lte: "<=",
+	gt: ">",
+	gte: ">="
+};
+function operandToSql(operand, scope) {
+	switch (operand.kind) {
+		case "field": return `${scope.fieldPrefix}${resolveColumnName(operand.name, scope.fieldCollection)}`;
+		case "outerField": return `${scope.outerPrefix}${resolveColumnName(operand.name, scope.outerCollection)}`;
+		case "literal": return quoteLiteral(operand.value);
+		case "authUid": return "auth.uid()";
+		case "authRoles": return "string_to_array(auth.roles(), ',')";
+	}
+}
+/**
+* SQL prefix that qualifies a column of the outer RLS row (`"schema"."table".`),
+* or `""` when the collection is unknown.
+*/
+function outerQualifier(scope) {
+	const table = scope.outerCollection ? getTableName(scope.outerCollection) : void 0;
+	if (!table) return "";
+	return `"${schemaOf(scope.outerCollection) ?? "public"}"."${table}".`;
+}
+function schemaOf(collection) {
+	return collection?.schema || void 0;
+}
+function resolveColumnName(propName, collection) {
+	const prop = collection?.properties?.[propName];
+	if (prop && "columnName" in prop && typeof prop.columnName === "string") return prop.columnName;
+	return toSnakeCase(propName);
+}
+function quoteLiteral(value) {
+	if (value === null) return "NULL";
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (typeof value === "number") return String(value);
+	return `'${value.replace(/'/g, "''")}'`;
+}
+/** Sorted, single-quoted `ARRAY['a','b']` — matches the generators' output. */
+function rolesArraySql(roles) {
+	return `ARRAY[${[...roles].sort().map((r) => `'${r}'`).join(",")}]`;
+}
+//#endregion
+//#region ../common/src/util/callbacks.ts
+/**
+* Helper function to recursively check if there are any callbacks in the properties.
+*/
+function hasPropertyCallbacks(properties, callbackName) {
+	if (!properties) return false;
+	for (const property of Object.values(properties)) {
+		if (property.callbacks?.[callbackName]) return true;
+		if (property.type === "map" && property.properties) {
+			if (hasPropertyCallbacks(property.properties, callbackName)) return true;
+		} else if (property.type === "array" && property.of) {
+			const ofs = Array.isArray(property.of) ? property.of : [property.of];
+			for (const of of ofs) {
+				if (of.callbacks?.[callbackName]) return true;
+				if (of.type === "map" && of.properties && hasPropertyCallbacks(of.properties, callbackName)) return true;
+			}
+		}
+	}
+	return false;
+}
+/**
+* Recursively process properties to apply field-level hooks.
+*/
+async function processProperties(properties, values, previousValues, propsContext, callbackName) {
+	if (!values || typeof values !== "object") return values;
+	const result = { ...values };
+	for (const [key, property] of Object.entries(properties)) {
+		if (result[key] === void 0) continue;
+		let currentValue = result[key];
+		const previousValue = previousValues?.[key];
+		if (property.type === "array" && Array.isArray(currentValue)) {
+			if (property.of && !Array.isArray(property.of)) currentValue = await Promise.all(currentValue.map(async (item, index) => {
+				const prevItem = Array.isArray(previousValue) ? previousValue[index] : void 0;
+				return (await processProperties({ "_tmp": property.of }, { "_tmp": item }, { "_tmp": prevItem }, propsContext, callbackName))["_tmp"];
+			}));
+		} else if (property.type === "map" && property.properties && typeof currentValue === "object") currentValue = await processProperties(property.properties, currentValue, previousValue ?? {}, propsContext, callbackName);
+		if (property.callbacks?.[callbackName]) {
+			const cbRes = await Promise.resolve(property.callbacks[callbackName]({
+				...propsContext,
+				value: currentValue,
+				previousValue
+			}));
+			if (cbRes !== void 0) currentValue = cbRes;
+		}
+		result[key] = currentValue;
+	}
+	return result;
+}
+/**
+* Helper function to extract field-level PropertyCallbacks from a properties schema
+* and wrap them into an CollectionCallbacks object recursively.
+*/
+var buildPropertyCallbacks = (properties) => {
+	if (!properties) return void 0;
+	const propertyCallbacks = {};
+	if (hasPropertyCallbacks(properties, "afterRead")) propertyCallbacks.afterRead = async (props) => {
+		const row = props.row;
+		const processedValues = await processProperties(properties, row, row, props, "afterRead");
+		return {
+			...props.row,
+			...processedValues
+		};
+	};
+	if (hasPropertyCallbacks(properties, "beforeSave")) propertyCallbacks.beforeSave = async (props) => {
+		return await processProperties(properties, props.values, props.previousValues ?? {}, props, "beforeSave");
+	};
+	return Object.keys(propertyCallbacks).length > 0 ? propertyCallbacks : void 0;
+};
+//#endregion
+//#region ../common/src/util/auth-default-policies.ts
+/**
+* Default RLS policies injected by the schema generator.
+*
+* Rebase's enforcement model is unified: authenticated (user-context) requests
+* run under the restricted `rebase_user` role, so Postgres RLS binds *every*
+* statement — reads and writes. A collection's `securityRules` are the whole
+* authorization model. The server context (auth flows, migrations,
+* `dataAsAdmin`) runs as the owner and bypasses RLS.
+*
+* Because RLS default-denies, every collection is **locked by default**: with
+* no rules, only the server context and admins can touch it. The generator
+* injects that safe baseline:
+*
+* **For every collection**
+*  1. A permissive **server-or-admin SELECT** grant.
+*  2. A permissive **server-or-admin write** grant (insert/update/delete).
+*
+* Author `securityRules` are permissive and OR together, so explicit rules only
+* *broaden* access from this locked baseline (e.g. "users read/write their own
+* rows").
+*
+* **For auth collections additionally**
+*  3. A permissive **self SELECT** grant (`id = auth.uid()`), so users can read
+*     their own row (profile, session bootstrap) without every app re-declaring
+*     it.
+*  4. A **restrictive** admin write gate. Restrictive policies are AND'd with
+*     every other policy, so a write is rejected unless the caller is an admin
+*     (or the server context) — even if the author also wrote a permissive rule
+*     such as "a user may edit their own row". Without this, a permissive owner
+*     rule would let a user change their own `roles`.
+*
+* The server context is recognised as `auth.uid() IS NULL` (`policy.serverContext()`)
+* — the built-in flows that run without a user (signup, migrations) set no user
+* GUC — which also lets the owner connection satisfy these policies even under
+* FORCE RLS. A *user* request never reaches that state: an anonymous one carries
+* `ANONYMOUS_USER_ID`, precisely so it cannot pass for the server here.
+*
+* Opt out with `disableDefaultPolicies: true` to take full responsibility for
+* the collection's RLS.
+*/
+var SERVER_OR_ADMIN_EXPR$1 = policy.or(policy.serverContext(), policy.rolesOverlap(["admin"]));
+/** Write operations that must be admin-gated by default on auth collections. */
+var DEFAULT_GUARDED_OPS = [
+	"insert",
+	"update",
+	"delete"
+];
+/** Whether a collection is flagged as an authentication collection. */
+function isAuthCollection(collection) {
+	const auth = collection.auth;
+	return auth === true || typeof auth === "object" && auth?.enabled === true;
+}
+/** The property marked as the row id (falls back to `id`). */
+function getIdPropertyName$1(collection) {
+	for (const [name, prop] of Object.entries(collection.properties ?? {})) if (prop && typeof prop === "object" && "isId" in prop && prop.isId) return name;
+	return "id";
+}
+/**
+* Returns the security rules that should be applied to a collection: the
+* author's explicit `securityRules` plus the framework defaults described in
+* the module doc (baseline server/admin read for all collections; self-read
+* and the admin write gate for auth collections).
+*
+* Collections that opt out via `disableDefaultPolicies` are returned unchanged.
+*/
+function getEffectiveSecurityRules(collection) {
+	const explicit = [...(isPostgresCollectionConfig(collection) ? collection.securityRules : void 0) ?? []];
+	if (collection.disableDefaultPolicies) return explicit;
+	const tableName = getTableName(collection);
+	const injected = [];
+	injected.push({
+		name: `${tableName}_default_admin_read`,
+		operations: ["select"],
+		condition: SERVER_OR_ADMIN_EXPR$1
+	});
+	injected.push({
+		name: `${tableName}_default_admin_write`,
+		operations: [...DEFAULT_GUARDED_OPS],
+		condition: SERVER_OR_ADMIN_EXPR$1,
+		check: SERVER_OR_ADMIN_EXPR$1
+	});
+	if (isAuthCollection(collection)) {
+		injected.push({
+			name: `${tableName}_default_self_read`,
+			operations: ["select"],
+			condition: policy.compare(policy.field(getIdPropertyName$1(collection)), "eq", policy.authUid())
+		});
+		injected.push({
+			name: `${tableName}_require_admin_write`,
+			mode: "restrictive",
+			operations: [...DEFAULT_GUARDED_OPS],
+			condition: SERVER_OR_ADMIN_EXPR$1,
+			check: SERVER_OR_ADMIN_EXPR$1
+		});
+	}
+	return [...explicit, ...injected];
+}
+//#endregion
+//#region ../common/src/util/junction-policies.ts
+var SERVER_OR_ADMIN_EXPR = policy.or(policy.serverContext(), policy.rolesOverlap(["admin"]));
+/**
+* Walk every collection's resolved relations and aggregate the junction tables
+* they declare. Two collections may declare the same junction from opposite
+* sides (posts→tags and tags→posts through `posts_tags`); both become
+* `declaringSides` of one spec, so derived write grants consider both.
+*/
+function resolveJunctionSpecs(collections) {
+	const specs = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const resolved = resolveCollectionRelations(collection);
+		for (const relation of Object.values(resolved)) {
+			if (!relation.through) continue;
+			const targetCollection = typeof relation.target === "function" ? relation.target() : void 0;
+			if (!targetCollection) continue;
+			const rawName = relation.through.table;
+			const table = rawName.includes(".") ? rawName.split(".").pop() : rawName;
+			const schema = "public";
+			const source = {
+				collection,
+				junctionColumn: relation.through.sourceColumn,
+				relation
+			};
+			const target = {
+				collection: targetCollection,
+				junctionColumn: relation.through.targetColumn
+			};
+			const existing = specs.get(table);
+			if (!existing) specs.set(table, {
+				table,
+				schema,
+				endpoints: [source, target],
+				declaringSides: [source]
+			});
+			else if (!existing.declaringSides.some((s) => s.collection === collection)) existing.declaringSides.push(source);
+		}
+	}
+	return specs;
+}
+/**
+* A synthetic CollectionConfig standing in for the junction during policy
+* compilation and naming. Its two FK columns carry explicit `columnName`s so
+* `outerField` operands resolve to the exact columns the CREATE TABLE emitted,
+* whatever their casing.
+*/
+function getJunctionCollectionConfig(spec) {
+	const properties = {};
+	for (const endpoint of spec.endpoints) properties[endpoint.junctionColumn] = {
+		type: "string",
+		columnName: endpoint.junctionColumn
+	};
+	return {
+		slug: spec.table,
+		name: spec.table,
+		table: spec.table,
+		schema: spec.schema,
+		properties
+	};
+}
+/** The property marked as the row id (falls back to `id`). */
+function getIdPropertyName(collection) {
+	for (const [name, prop] of Object.entries(collection.properties ?? {})) if (prop && typeof prop === "object" && "isId" in prop && prop.isId) return name;
+	return "id";
+}
+/** `EXISTS (SELECT 1 FROM endpoint WHERE endpoint.pk = junction.fk [AND extra])`. */
+function existsEndpoint(endpoint, extra) {
+	const correlation = policy.compare(policy.field(getIdPropertyName(endpoint.collection)), "eq", policy.outerField(endpoint.junctionColumn));
+	return policy.existsIn({
+		collection: endpoint.collection.slug,
+		where: extra ? policy.and(correlation, extra) : correlation
+	});
+}
+/**
+* Whether a parent-rule expression keeps its meaning when moved inside the
+* junction's `EXISTS` subquery — and the re-scoped copy if it does.
+*
+* Returns `null` when the rule cannot be embedded faithfully: `raw` SQL
+* anywhere (its `{column}` placeholders would bind to the junction), or an
+* `outerField` inside a nested `existsIn` (it would bind to the junction while
+* the author meant the parent, and no operand can express "the middle scope").
+* Top-level `outerField`s are rewritten to `field`, which is what they meant.
+*/
+function embedParentExpression(expr, depth = 0) {
+	switch (expr.kind) {
+		case "raw": return null;
+		case "and":
+		case "or": {
+			const parts = [];
+			for (const child of expr.operands) {
+				const embedded = embedParentExpression(child, depth);
+				if (!embedded) return null;
+				parts.push(embedded);
+			}
+			return expr.kind === "and" ? policy.and(...parts) : policy.or(...parts);
+		}
+		case "not": {
+			const embedded = embedParentExpression(expr.operand, depth);
+			return embedded ? policy.not(embedded) : null;
+		}
+		case "existsIn": {
+			const where = embedParentExpression(expr.where, depth + 1);
+			return where ? policy.existsIn({
+				collection: expr.collection,
+				where
+			}) : null;
+		}
+		case "compare": {
+			const left = embedOperand(expr.left, depth);
+			const right = embedOperand(expr.right, depth);
+			if (!left || !right) return null;
+			return {
+				...expr,
+				left,
+				right
+			};
+		}
+		default: return expr;
+	}
+}
+/** Re-scope an operand, or return `null` if its binding cannot be preserved. */
+function embedOperand(operand, depth) {
+	if (operand.kind === "outerField") {
+		if (depth === 0) return policy.field(operand.name);
+		return null;
+	}
+	return operand;
+}
+/** Does the rule cover the `update` operation? */
+function coversUpdate(rule) {
+	return getPolicyOperations(rule).some((op) => op === "update" || op === "all");
+}
+/**
+* The full derived policy set for a junction table: the locked server/admin
+* baseline, the endpoint-visibility read grant, inherited write grants, and
+* inherited restrictive gates. Returns `[]` when every declaring collection set
+* `disableDefaultPolicies` — the junction is then the author's to police, and
+* stays locked (RLS is still enabled) until they write policies for it.
+*/
+function getJunctionSecurityRules(spec) {
+	if (spec.declaringSides.every((side) => side.collection.disableDefaultPolicies)) return [];
+	const rules = [];
+	rules.push({
+		name: `${spec.table}_default_admin_read`,
+		operations: ["select"],
+		condition: SERVER_OR_ADMIN_EXPR
+	});
+	rules.push({
+		name: `${spec.table}_default_admin_write`,
+		operations: [
+			"insert",
+			"update",
+			"delete"
+		],
+		condition: SERVER_OR_ADMIN_EXPR,
+		check: SERVER_OR_ADMIN_EXPR
+	});
+	rules.push({
+		name: `${spec.table}_default_edge_read`,
+		operations: ["select"],
+		condition: policy.and(existsEndpoint(spec.endpoints[0]), existsEndpoint(spec.endpoints[1]))
+	});
+	const writeGrants = [];
+	for (const side of spec.declaringSides) {
+		const updateRules = ((isPostgresCollectionConfig(side.collection) ? side.collection.securityRules : void 0) ?? []).filter(coversUpdate);
+		const permissive = updateRules.filter((r) => r.mode !== "restrictive");
+		const restrictive = updateRules.filter((r) => r.mode === "restrictive");
+		const embeddedGates = [];
+		let gatesEmbeddable = true;
+		for (const gate of restrictive) {
+			const using = securityRuleToConditions(gate).usingExpr;
+			const embedded = using ? embedParentExpression(using) : null;
+			if (!embedded) {
+				gatesEmbeddable = false;
+				break;
+			}
+			embeddedGates.push(embedded);
+		}
+		if (!gatesEmbeddable) continue;
+		const grants = [];
+		for (const rule of permissive) {
+			const using = securityRuleToConditions(rule).usingExpr;
+			const embedded = using ? embedParentExpression(using) : null;
+			if (embedded) grants.push(embedded);
+		}
+		if (grants.length === 0) continue;
+		const condition = embeddedGates.length > 0 ? policy.and(policy.or(...grants), ...embeddedGates) : policy.or(...grants);
+		writeGrants.push(existsEndpoint(side, condition));
+	}
+	if (writeGrants.length > 0) rules.push({
+		name: `${spec.table}_default_edge_write`,
+		operations: [
+			"insert",
+			"update",
+			"delete"
+		],
+		condition: writeGrants.length === 1 ? writeGrants[0] : policy.or(...writeGrants),
+		check: writeGrants.length === 1 ? writeGrants[0] : policy.or(...writeGrants)
+	});
+	return rules;
+}
+(/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory) {
+		if (typeof define === "function" && define.amd) define(factory);
+		else if (typeof exports === "object") module.exports = factory();
+		else root.jsonLogic = factory();
+	})(exports, function() {
+		"use strict";
+		if (!Array.isArray) Array.isArray = function(arg) {
+			return Object.prototype.toString.call(arg) === "[object Array]";
+		};
+		/**
+		* Return an array that contains no duplicates (original not modified)
+		* @param  {array} array   Original reference array
+		* @return {array}         New array with no duplicates
+		*/
+		function arrayUnique(array) {
+			var a = [];
+			for (var i = 0, l = array.length; i < l; i++) if (a.indexOf(array[i]) === -1) a.push(array[i]);
+			return a;
+		}
+		var jsonLogic = {};
+		var operations = {
+			"==": function(a, b) {
+				return a == b;
+			},
+			"===": function(a, b) {
+				return a === b;
+			},
+			"!=": function(a, b) {
+				return a != b;
+			},
+			"!==": function(a, b) {
+				return a !== b;
+			},
+			">": function(a, b) {
+				return a > b;
+			},
+			">=": function(a, b) {
+				return a >= b;
+			},
+			"<": function(a, b, c) {
+				return c === void 0 ? a < b : a < b && b < c;
+			},
+			"<=": function(a, b, c) {
+				return c === void 0 ? a <= b : a <= b && b <= c;
+			},
+			"!!": function(a) {
+				return jsonLogic.truthy(a);
+			},
+			"!": function(a) {
+				return !jsonLogic.truthy(a);
+			},
+			"%": function(a, b) {
+				return a % b;
+			},
+			"log": function(a) {
+				console.log(a);
+				return a;
+			},
+			"in": function(a, b) {
+				if (!b || typeof b.indexOf === "undefined") return false;
+				return b.indexOf(a) !== -1;
+			},
+			"cat": function() {
+				return Array.prototype.join.call(arguments, "");
+			},
+			"substr": function(source, start, end) {
+				if (end < 0) {
+					var temp = String(source).substr(start);
+					return temp.substr(0, temp.length + end);
+				}
+				return String(source).substr(start, end);
+			},
+			"+": function() {
+				return Array.prototype.reduce.call(arguments, function(a, b) {
+					return parseFloat(a, 10) + parseFloat(b, 10);
+				}, 0);
+			},
+			"*": function() {
+				return Array.prototype.reduce.call(arguments, function(a, b) {
+					return parseFloat(a, 10) * parseFloat(b, 10);
+				});
+			},
+			"-": function(a, b) {
+				if (b === void 0) return -a;
+				else return a - b;
+			},
+			"/": function(a, b) {
+				return a / b;
+			},
+			"min": function() {
+				return Math.min.apply(this, arguments);
+			},
+			"max": function() {
+				return Math.max.apply(this, arguments);
+			},
+			"merge": function() {
+				return Array.prototype.reduce.call(arguments, function(a, b) {
+					return a.concat(b);
+				}, []);
+			},
+			"var": function(a, b) {
+				var not_found = b === void 0 ? null : b;
+				var data = this;
+				if (typeof a === "undefined" || a === "" || a === null) return data;
+				var sub_props = String(a).split(".");
+				for (var i = 0; i < sub_props.length; i++) {
+					if (data === null || data === void 0) return not_found;
+					data = data[sub_props[i]];
+					if (data === void 0) return not_found;
+				}
+				return data;
+			},
+			"missing": function() {
+				var missing = [];
+				var keys = Array.isArray(arguments[0]) ? arguments[0] : arguments;
+				for (var i = 0; i < keys.length; i++) {
+					var key = keys[i];
+					var value = jsonLogic.apply({ "var": key }, this);
+					if (value === null || value === "") missing.push(key);
+				}
+				return missing;
+			},
+			"missing_some": function(need_count, options) {
+				var are_missing = jsonLogic.apply({ "missing": options }, this);
+				if (options.length - are_missing.length >= need_count) return [];
+				else return are_missing;
+			}
+		};
+		jsonLogic.is_logic = function(logic) {
+			return typeof logic === "object" && logic !== null && !Array.isArray(logic) && Object.keys(logic).length === 1;
+		};
+		jsonLogic.truthy = function(value) {
+			if (Array.isArray(value) && value.length === 0) return false;
+			return !!value;
+		};
+		jsonLogic.get_operator = function(logic) {
+			return Object.keys(logic)[0];
+		};
+		jsonLogic.get_values = function(logic) {
+			return logic[jsonLogic.get_operator(logic)];
+		};
+		jsonLogic.apply = function(logic, data) {
+			if (Array.isArray(logic)) return logic.map(function(l) {
+				return jsonLogic.apply(l, data);
+			});
+			if (!jsonLogic.is_logic(logic)) return logic;
+			var op = jsonLogic.get_operator(logic);
+			var values = logic[op];
+			var i;
+			var current;
+			var scopedLogic;
+			var scopedData;
+			var initial;
+			if (!Array.isArray(values)) values = [values];
+			if (op === "if" || op == "?:") {
+				for (i = 0; i < values.length - 1; i += 2) if (jsonLogic.truthy(jsonLogic.apply(values[i], data))) return jsonLogic.apply(values[i + 1], data);
+				if (values.length === i + 1) return jsonLogic.apply(values[i], data);
+				return null;
+			} else if (op === "and") {
+				for (i = 0; i < values.length; i += 1) {
+					current = jsonLogic.apply(values[i], data);
+					if (!jsonLogic.truthy(current)) return current;
+				}
+				return current;
+			} else if (op === "or") {
+				for (i = 0; i < values.length; i += 1) {
+					current = jsonLogic.apply(values[i], data);
+					if (jsonLogic.truthy(current)) return current;
+				}
+				return current;
+			} else if (op === "filter") {
+				scopedData = jsonLogic.apply(values[0], data);
+				scopedLogic = values[1];
+				if (!Array.isArray(scopedData)) return [];
+				return scopedData.filter(function(datum) {
+					return jsonLogic.truthy(jsonLogic.apply(scopedLogic, datum));
+				});
+			} else if (op === "map") {
+				scopedData = jsonLogic.apply(values[0], data);
+				scopedLogic = values[1];
+				if (!Array.isArray(scopedData)) return [];
+				return scopedData.map(function(datum) {
+					return jsonLogic.apply(scopedLogic, datum);
+				});
+			} else if (op === "reduce") {
+				scopedData = jsonLogic.apply(values[0], data);
+				scopedLogic = values[1];
+				initial = typeof values[2] !== "undefined" ? jsonLogic.apply(values[2], data) : null;
+				if (!Array.isArray(scopedData)) return initial;
+				return scopedData.reduce(function(accumulator, current) {
+					return jsonLogic.apply(scopedLogic, {
+						current,
+						accumulator
+					});
+				}, initial);
+			} else if (op === "all") {
+				scopedData = jsonLogic.apply(values[0], data);
+				scopedLogic = values[1];
+				if (!Array.isArray(scopedData) || !scopedData.length) return false;
+				for (i = 0; i < scopedData.length; i += 1) if (!jsonLogic.truthy(jsonLogic.apply(scopedLogic, scopedData[i]))) return false;
+				return true;
+			} else if (op === "none") {
+				scopedData = jsonLogic.apply(values[0], data);
+				scopedLogic = values[1];
+				if (!Array.isArray(scopedData) || !scopedData.length) return true;
+				for (i = 0; i < scopedData.length; i += 1) if (jsonLogic.truthy(jsonLogic.apply(scopedLogic, scopedData[i]))) return false;
+				return true;
+			} else if (op === "some") {
+				scopedData = jsonLogic.apply(values[0], data);
+				scopedLogic = values[1];
+				if (!Array.isArray(scopedData) || !scopedData.length) return false;
+				for (i = 0; i < scopedData.length; i += 1) if (jsonLogic.truthy(jsonLogic.apply(scopedLogic, scopedData[i]))) return true;
+				return false;
+			}
+			values = values.map(function(val) {
+				return jsonLogic.apply(val, data);
+			});
+			if (operations.hasOwnProperty(op) && typeof operations[op] === "function") return operations[op].apply(data, values);
+			else if (op.indexOf(".") > 0) {
+				var sub_ops = String(op).split(".");
+				var operation = operations;
+				for (i = 0; i < sub_ops.length; i++) {
+					if (!operation.hasOwnProperty(sub_ops[i])) throw new Error("Unrecognized operation " + op + " (failed at " + sub_ops.slice(0, i + 1).join(".") + ")");
+					operation = operation[sub_ops[i]];
+				}
+				return operation.apply(data, values);
+			}
+			throw new Error("Unrecognized operation " + op);
+		};
+		jsonLogic.uses_data = function(logic) {
+			var collection = [];
+			if (jsonLogic.is_logic(logic)) {
+				var op = jsonLogic.get_operator(logic);
+				var values = logic[op];
+				if (!Array.isArray(values)) values = [values];
+				if (op === "var") collection.push(values[0]);
+				else values.forEach(function(val) {
+					collection.push.apply(collection, jsonLogic.uses_data(val));
+				});
+			}
+			return arrayUnique(collection);
+		};
+		jsonLogic.add_operation = function(name, code) {
+			operations[name] = code;
+		};
+		jsonLogic.rm_operation = function(name) {
+			delete operations[name];
+		};
+		jsonLogic.rule_like = function(rule, pattern) {
+			if (pattern === rule) return true;
+			if (pattern === "@") return true;
+			if (pattern === "number") return typeof rule === "number";
+			if (pattern === "string") return typeof rule === "string";
+			if (pattern === "array") return Array.isArray(rule) && !jsonLogic.is_logic(rule);
+			if (jsonLogic.is_logic(pattern)) {
+				if (jsonLogic.is_logic(rule)) {
+					var pattern_op = jsonLogic.get_operator(pattern);
+					var rule_op = jsonLogic.get_operator(rule);
+					if (pattern_op === "@" || pattern_op === rule_op) return jsonLogic.rule_like(jsonLogic.get_values(rule, false), jsonLogic.get_values(pattern, false));
+				}
+				return false;
+			}
+			if (Array.isArray(pattern)) if (Array.isArray(rule)) {
+				if (pattern.length !== rule.length) return false;
+				for (var i = 0; i < pattern.length; i += 1) if (!jsonLogic.rule_like(rule[i], pattern[i])) return false;
+				return true;
+			} else return false;
+			return false;
+		};
+		return jsonLogic;
+	});
+})))();
+//#endregion
+//#region ../common/src/util/filter-operator-resolution.ts
+/**
+* Default operators offered per property type, before engine capabilities and
+* per-property narrowing are applied. These mirror what the built-in filter
+* fields can render.
+*/
+var COMPARISON_OPS = [
+	"==",
+	"!=",
+	">",
+	">=",
+	"<",
+	"<="
+];
+var NULL_CHECK_OPS = ["is-null", "is-not-null"];
+var MEMBERSHIP_OPS = ["in", "not-in"];
+var PATTERN_OPS = [
+	"like",
+	"ilike",
+	"not-like",
+	"not-ilike"
+];
+[
+	...COMPARISON_OPS,
+	...MEMBERSHIP_OPS,
+	...PATTERN_OPS,
+	...NULL_CHECK_OPS
+], [
+	...COMPARISON_OPS,
+	...MEMBERSHIP_OPS,
+	...NULL_CHECK_OPS
+], [...COMPARISON_OPS, ...NULL_CHECK_OPS], [...NULL_CHECK_OPS], [...MEMBERSHIP_OPS, ...NULL_CHECK_OPS], [...MEMBERSHIP_OPS, ...NULL_CHECK_OPS];
+//#endregion
+//#region ../../node_modules/.pnpm/fast-equals@6.0.0/node_modules/fast-equals/dist/es/index.mjs
+var { getOwnPropertyNames, getOwnPropertySymbols } = Object;
+var { hasOwnProperty } = Object.prototype;
+/**
+* Combine two comparators into a single comparators.
+*/
+function combineComparators(comparatorA, comparatorB) {
+	return function isEqual(a, b, state) {
+		return comparatorA(a, b, state) && comparatorB(a, b, state);
+	};
+}
+/**
+* Wrap the provided `areItemsEqual` method to manage the circular state, allowing
+* for circular references to be safely included in the comparison without creating
+* stack overflows.
+*/
+function createIsCircular(areItemsEqual) {
+	return function isCircular(a, b, state) {
+		if (!a || !b || typeof a !== "object" || typeof b !== "object") return areItemsEqual(a, b, state);
+		const { cache } = state;
+		const cachedA = cache.get(a);
+		const cachedB = cache.get(b);
+		if (cachedA && cachedB) return cachedA === b && cachedB === a;
+		cache.set(a, b);
+		cache.set(b, a);
+		const result = areItemsEqual(a, b, state);
+		cache.delete(a);
+		cache.delete(b);
+		return result;
+	};
+}
+/**
+* Get the properties to strictly examine, which include both own properties that are
+* not enumerable and symbol properties.
+*/
+function getStrictProperties(object) {
+	return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+}
+/**
+* Whether the object contains the property passed as an own property.
+*/
+var hasOwn = Object.hasOwn || ((object, property) => hasOwnProperty.call(object, property));
+var PREACT_VNODE = "__v";
+var PREACT_OWNER = "__o";
+var REACT_OWNER = "_owner";
+var { getOwnPropertyDescriptor, keys } = Object;
+/**
+* Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+* Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+*
+* @note
+* When available in the environment, this is just a re-export of the global
+* [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+*/
+var sameValueEqual = Object.is || function sameValueEqual(a, b) {
+	return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b;
+};
+/**
+* Whether the values passed are equal based on a
+* [Strict Equality Comparison](https://262.ecma-international.org/7.0/#sec-strict-equality-comparison) basis.
+* Simplified, this maps to if the two values are referentially equal to one another (`a === b`).
+*
+* @note
+* This is mainly available as a convenience function, such as being a default when a function to determine equality between
+* two objects is used.
+*/
+function strictEqual(a, b) {
+	return a === b;
+}
+/**
+* Whether the array buffers are equal in value.
+*/
+function areArrayBuffersEqual(a, b) {
+	return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a), new Uint8Array(b));
+}
+/**
+* Whether the arrays are equal in value.
+*/
+function areArraysEqual(a, b, state) {
+	let index = a.length;
+	if (b.length !== index) return false;
+	while (index-- > 0) if (!state.equals(a[index], b[index], index, index, a, b, state)) return false;
+	return true;
+}
+/**
+* Whether the dataviews are equal in value.
+*/
+function areDataViewsEqual(a, b) {
+	return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength));
+}
+/**
+* Whether the dates passed are equal in value.
+*/
+function areDatesEqual(a, b) {
+	return sameValueEqual(a.getTime(), b.getTime());
+}
+/**
+* Whether the errors passed are equal in value.
+*/
+function areErrorsEqual(a, b) {
+	return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
+}
+/**
+* Whether the `Map`s are equal in value.
+*/
+function areMapsEqual(a, b, state) {
+	const size = a.size;
+	if (size !== b.size) return false;
+	if (!size) return true;
+	const matchedIndices = new Array(size);
+	const aIterable = a.entries();
+	let aResult;
+	let bResult;
+	let index = 0;
+	while (aResult = aIterable.next()) {
+		if (aResult.done) break;
+		const bIterable = b.entries();
+		let hasMatch = false;
+		let matchIndex = 0;
+		while (bResult = bIterable.next()) {
+			if (bResult.done) break;
+			if (matchedIndices[matchIndex]) {
+				matchIndex++;
+				continue;
+			}
+			const aEntry = aResult.value;
+			const bEntry = bResult.value;
+			if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
+				hasMatch = matchedIndices[matchIndex] = true;
+				break;
+			}
+			matchIndex++;
+		}
+		if (!hasMatch) return false;
+		index++;
+	}
+	return true;
+}
+/**
+* Whether the objects are equal in value.
+*/
+function areObjectsEqual(a, b, state) {
+	const properties = keys(a);
+	let index = properties.length;
+	if (keys(b).length !== index) return false;
+	while (index-- > 0) if (!isPropertyEqual(a, b, state, properties[index])) return false;
+	return true;
+}
+/**
+* Whether the objects are equal in value with strict property checking.
+*/
+function areObjectsEqualStrict(a, b, state) {
+	const properties = getStrictProperties(a);
+	let index = properties.length;
+	if (getStrictProperties(b).length !== index) return false;
+	let property;
+	let descriptorA;
+	let descriptorB;
+	while (index-- > 0) {
+		property = properties[index];
+		if (!isPropertyEqual(a, b, state, property)) return false;
+		descriptorA = getOwnPropertyDescriptor(a, property);
+		descriptorB = getOwnPropertyDescriptor(b, property);
+		if ((descriptorA || descriptorB) && (!descriptorA || !descriptorB || descriptorA.configurable !== descriptorB.configurable || descriptorA.enumerable !== descriptorB.enumerable || descriptorA.writable !== descriptorB.writable)) return false;
+	}
+	return true;
+}
+/**
+* Whether the primitive wrappers passed are equal in value.
+*/
+function arePrimitiveWrappersEqual(a, b) {
+	return sameValueEqual(a.valueOf(), b.valueOf());
+}
+/**
+* Whether the regexps passed are equal in value.
+*/
+function areRegExpsEqual(a, b) {
+	return a.source === b.source && a.flags === b.flags;
+}
+/**
+* Whether the `Set`s are equal in value.
+*/
+function areSetsEqual(a, b, state) {
+	const size = a.size;
+	if (size !== b.size) return false;
+	if (!size) return true;
+	const matchedIndices = new Array(size);
+	const aIterable = a.values();
+	let aResult;
+	let bResult;
+	while (aResult = aIterable.next()) {
+		if (aResult.done) break;
+		const bIterable = b.values();
+		let hasMatch = false;
+		let matchIndex = 0;
+		while (bResult = bIterable.next()) {
+			if (bResult.done) break;
+			if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
+				hasMatch = matchedIndices[matchIndex] = true;
+				break;
+			}
+			matchIndex++;
+		}
+		if (!hasMatch) return false;
+	}
+	return true;
+}
+/**
+* Whether the TypedArray instances are equal in value.
+*/
+function areTypedArraysEqual(a, b) {
+	let index = a.byteLength;
+	if (b.byteLength !== index || a.byteOffset !== b.byteOffset) return false;
+	while (index-- > 0) if (a[index] !== b[index]) return false;
+	return true;
+}
+/**
+* Whether the URL instances are equal in value.
+*/
+function areUrlsEqual(a, b) {
+	return a.hostname === b.hostname && a.pathname === b.pathname && a.protocol === b.protocol && a.port === b.port && a.hash === b.hash && a.username === b.username && a.password === b.password;
+}
+function isPropertyEqual(a, b, state, property) {
+	if ((property === REACT_OWNER || property === PREACT_OWNER || property === PREACT_VNODE) && (a.$$typeof || b.$$typeof)) return true;
+	return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
+}
+var toString = Object.prototype.toString;
+/**
+* Create a comparator method based on the type-specific equality comparators passed.
+*/
+function createEqualityComparator(config) {
+	const supportedComparatorMap = createSupportedComparatorMap(config);
+	const { areArraysEqual, areDatesEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, areRegExpsEqual, areSetsEqual, getUnsupportedCustomComparator } = config;
+	/**
+	* compare the value of the two objects and return true if they are equivalent in values
+	*/
+	return function comparator(a, b, state) {
+		if (a === b) return true;
+		if (a == null || b == null) return false;
+		const type = typeof a;
+		if (type !== typeof b) return false;
+		if (type !== "object") {
+			if (type === "number" || type === "bigint") return areNumbersEqual(a, b, state);
+			if (type === "function") return areFunctionsEqual(a, b, state);
+			return false;
+		}
+		const constructor = a.constructor;
+		if (constructor !== b.constructor) return false;
+		if (constructor === Object) return areObjectsEqual(a, b, state);
+		if (constructor === Array) return areArraysEqual(a, b, state);
+		if (constructor === Date) return areDatesEqual(a, b, state);
+		if (constructor === RegExp) return areRegExpsEqual(a, b, state);
+		if (constructor === Map) return areMapsEqual(a, b, state);
+		if (constructor === Set) return areSetsEqual(a, b, state);
+		if (constructor === Promise) return false;
+		if (Array.isArray(a)) return areArraysEqual(a, b, state);
+		const tag = toString.call(a);
+		const supportedComparator = supportedComparatorMap[tag];
+		if (supportedComparator) return supportedComparator(a, b, state);
+		const unsupportedCustomComparator = getUnsupportedCustomComparator && getUnsupportedCustomComparator(a, b, state, tag);
+		if (unsupportedCustomComparator) return unsupportedCustomComparator(a, b, state);
+		return false;
+	};
+}
+/**
+* Create the configuration object used for building comparators.
+*/
+function createEqualityComparatorConfig({ circular, createCustomConfig, strict }) {
+	let config = {
+		areArrayBuffersEqual,
+		areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+		areDataViewsEqual,
+		areDatesEqual,
+		areErrorsEqual,
+		areFunctionsEqual: strictEqual,
+		areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
+		areNumbersEqual: sameValueEqual,
+		areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
+		arePrimitiveWrappersEqual,
+		areRegExpsEqual,
+		areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
+		areTypedArraysEqual: strict ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict) : areTypedArraysEqual,
+		areUrlsEqual,
+		getUnsupportedCustomComparator: void 0
+	};
+	if (createCustomConfig) config = Object.assign({}, config, createCustomConfig(config));
+	if (circular) {
+		const areArraysEqual = createIsCircular(config.areArraysEqual);
+		const areMapsEqual = createIsCircular(config.areMapsEqual);
+		const areObjectsEqual = createIsCircular(config.areObjectsEqual);
+		const areSetsEqual = createIsCircular(config.areSetsEqual);
+		config = Object.assign({}, config, {
+			areArraysEqual,
+			areMapsEqual,
+			areObjectsEqual,
+			areSetsEqual
+		});
+	}
+	return config;
+}
+/**
+* Default equality comparator pass-through, used as the standard `isEqual` creator for
+* use inside the built comparator.
+*/
+function createInternalEqualityComparator(compare) {
+	return function(a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {
+		return compare(a, b, state);
+	};
+}
+/**
+* Create the `isEqual` function used by the consuming application.
+*/
+function createIsEqual({ circular, comparator, createState, equals, strict }) {
+	if (createState) return function isEqual(a, b) {
+		const { cache = circular ? /* @__PURE__ */ new WeakMap() : void 0, meta } = createState();
+		return comparator(a, b, {
+			cache,
+			equals,
+			meta,
+			strict
+		});
+	};
+	if (circular) return function isEqual(a, b) {
+		return comparator(a, b, {
+			cache: /* @__PURE__ */ new WeakMap(),
+			equals,
+			meta: void 0,
+			strict
+		});
+	};
+	const state = {
+		cache: void 0,
+		equals,
+		meta: void 0,
+		strict
+	};
+	return function isEqual(a, b) {
+		return comparator(a, b, state);
+	};
+}
+/**
+* Create a map of `toString()` values to their respective handlers for `tag`-based lookups.
+*/
+function createSupportedComparatorMap({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual }) {
+	return {
+		"[object Arguments]": areObjectsEqual,
+		"[object Array]": areArraysEqual,
+		"[object ArrayBuffer]": areArrayBuffersEqual,
+		"[object AsyncGeneratorFunction]": areFunctionsEqual,
+		"[object BigInt]": areNumbersEqual,
+		"[object BigInt64Array]": areTypedArraysEqual,
+		"[object BigUint64Array]": areTypedArraysEqual,
+		"[object Boolean]": arePrimitiveWrappersEqual,
+		"[object DataView]": areDataViewsEqual,
+		"[object Date]": areDatesEqual,
+		"[object Error]": areErrorsEqual,
+		"[object Float16Array]": areTypedArraysEqual,
+		"[object Float32Array]": areTypedArraysEqual,
+		"[object Float64Array]": areTypedArraysEqual,
+		"[object Function]": areFunctionsEqual,
+		"[object GeneratorFunction]": areFunctionsEqual,
+		"[object Int8Array]": areTypedArraysEqual,
+		"[object Int16Array]": areTypedArraysEqual,
+		"[object Int32Array]": areTypedArraysEqual,
+		"[object Map]": areMapsEqual,
+		"[object Number]": arePrimitiveWrappersEqual,
+		"[object Object]": (a, b, state) => typeof a.then !== "function" && typeof b.then !== "function" && areObjectsEqual(a, b, state),
+		"[object RegExp]": areRegExpsEqual,
+		"[object Set]": areSetsEqual,
+		"[object String]": arePrimitiveWrappersEqual,
+		"[object URL]": areUrlsEqual,
+		"[object Uint8Array]": areTypedArraysEqual,
+		"[object Uint8ClampedArray]": areTypedArraysEqual,
+		"[object Uint16Array]": areTypedArraysEqual,
+		"[object Uint32Array]": areTypedArraysEqual
+	};
+}
+/**
+* Whether the items passed are deeply-equal in value.
+*/
+var deepEqual = createCustomEqual();
+createCustomEqual({ strict: true });
+createCustomEqual({ circular: true });
+createCustomEqual({
+	circular: true,
+	strict: true
+});
+createCustomEqual({ createInternalComparator: () => sameValueEqual });
+createCustomEqual({
+	strict: true,
+	createInternalComparator: () => sameValueEqual
+});
+createCustomEqual({
+	circular: true,
+	createInternalComparator: () => sameValueEqual
+});
+createCustomEqual({
+	circular: true,
+	createInternalComparator: () => sameValueEqual,
+	strict: true
+});
+/**
+* Create a custom equality comparison method.
+*
+* This can be done to create very targeted comparisons in extreme hot-path scenarios
+* where the standard methods are not performant enough, but can also be used to provide
+* support for legacy environments that do not support expected features like
+* `RegExp.prototype.flags` out of the box.
+*/
+function createCustomEqual(options = {}) {
+	const { circular = false, createInternalComparator: createCustomInternalComparator, createState, strict = false } = options;
+	const comparator = createEqualityComparator(createEqualityComparatorConfig(options));
+	return createIsEqual({
+		circular,
+		comparator,
+		createState,
+		equals: createCustomInternalComparator ? createCustomInternalComparator(comparator) : createInternalEqualityComparator(comparator),
+		strict
+	});
+}
+//#endregion
+//#region ../common/src/data/resolveDataSource.ts
+/**
+* Resolve the effective data source for a collection — the single source of
+* truth shared by the frontend router, the backend driver registry, and the
+* editor's capability lookups.
+*
+* Resolution order:
+* 1. The routing **key** is `collection.dataSource`, else
+*    {@link DEFAULT_DATA_SOURCE_KEY}.
+* 2. If a definition is registered for that key, it provides `engine`,
+*    `transport`, and `databaseId`.
+* 3. Otherwise values are synthesized: `engine` from `collection.engine`
+*    (or the key, or `"postgres"`), `transport` defaults to `"server"`,
+*    and `databaseId` from the collection.
+*
+* `capabilities` are always derived from the resolved `engine`, so two
+* data sources sharing an engine share capabilities.
+*
+* @param collection the collection (or any object carrying the routing fields)
+* @param registry   optional registry of declared data sources
+*/
+function resolveDataSource(collection, registry) {
+	const key = collection?.dataSource ?? "(default)";
+	const def = registry?.[key];
+	const engine = def?.engine ?? collection?.engine ?? (key !== "(default)" ? key : "postgres");
+	return {
+		key,
+		engine,
+		transport: def?.transport ?? "server",
+		databaseId: collection?.databaseId ?? def?.databaseId,
+		capabilities: getDataSourceCapabilities(engine)
+	};
+}
+//#endregion
+//#region ../common/src/collections/CollectionRegistry.ts
+var CollectionRegistry = class {
+	/**
+	* Declared data sources, used during normalization to resolve each
+	* collection's engine (so `dataSource`-only collections get the right
+	* capabilities). Empty by default.
+	*/
+	dataSources = {};
+	/**
+	* Global lifecycle callbacks applied to every collection.
+	* Runs on all data paths (REST, WebSocket, `rebase.data`).
+	* Execution order: global → collection → property callbacks.
+	*/
+	_globalCallbacks;
+	/**
+	* Set global lifecycle callbacks that apply to every collection.
+	* Typically called once during backend initialization.
+	*/
+	setGlobalCallbacks(callbacks) {
+		this._globalCallbacks = callbacks;
+	}
+	/**
+	* Get the currently registered global callbacks, if any.
+	*/
+	getGlobalCallbacks() {
+		return this._globalCallbacks;
+	}
+	collectionsByTableName = /* @__PURE__ */ new Map();
+	collectionsBySlug = /* @__PURE__ */ new Map();
+	rootCollections = [];
+	cachedCollectionsList = null;
+	rawCollectionsByTableName = /* @__PURE__ */ new Map();
+	rawCollectionsBySlug = /* @__PURE__ */ new Map();
+	rawRootCollections = [];
+	cachedRawCollectionsList = null;
+	lastRawInputEntity = null;
+	constructor(collections, dataSources) {
+		if (dataSources) this.dataSources = dataSources;
+		if (collections) this.registerMultiple(collections);
+	}
+	/**
+	* Provide the declared data sources used to resolve each collection's
+	* engine during normalization. Set this before registering collections.
+	* Returns true if the registry changed (callers may re-register).
+	*/
+	setDataSources(dataSources) {
+		if (deepEqual(this.dataSources, dataSources)) return false;
+		this.dataSources = dataSources ?? {};
+		return true;
+	}
+	reset() {
+		this.collectionsByTableName.clear();
+		this.collectionsBySlug.clear();
+		this.rootCollections = [];
+		this.cachedCollectionsList = null;
+		this.rawCollectionsByTableName.clear();
+		this.rawCollectionsBySlug.clear();
+		this.rawRootCollections = [];
+		this.cachedRawCollectionsList = null;
+	}
+	/**
+	* Registers a collection and its subcollections recursively.
+	* Returns true if the collections have changed, false otherwise.
+	*
+	* Idempotent: compares the raw input (before normalization) against a stored
+	* entity. Only re-normalizes and re-registers when the raw input actually changed.
+	* @param collections
+	*/
+	registerMultiple(collections) {
+		const rawEntity = collections.map((c) => removeFunctions(c));
+		if (this.lastRawInputEntity && deepEqual(this.lastRawInputEntity, rawEntity)) return false;
+		this.reset();
+		collections.forEach((c) => {
+			if (c.slug) this.collectionsBySlug.set(c.slug, c);
+			this.collectionsByTableName.set(getTableName(c), c);
+		});
+		const normalizedCollections = collections.map((c) => this.normalizeCollection({ ...c }));
+		normalizedCollections.forEach((c, index) => {
+			const raw = deepClone(collections[index]);
+			this.rootCollections.push(c);
+			this.rawRootCollections.push(raw);
+			const normalized = this.normalizeCollection(c);
+			this.collectionsByTableName.set(getTableName(normalized), normalized);
+			this.rawCollectionsByTableName.set(getTableName(raw), raw);
+			if (normalized.slug) this.collectionsBySlug.set(normalized.slug, normalized);
+			if (raw.slug) this.rawCollectionsBySlug.set(raw.slug, raw);
+		});
+		normalizedCollections.forEach((c) => {
+			const subcollections = getSubcollections(c);
+			if (subcollections && subcollections.length > 0) subcollections.forEach((subCollection) => {
+				if (!subCollection) return;
+				this._registerRecursively(this.normalizeCollection({ ...subCollection }), deepClone(subCollection));
+			});
+		});
+		this.lastRawInputEntity = rawEntity;
+		return true;
+	}
+	register(collection, rawCollection) {
+		const raw = rawCollection ? deepClone(rawCollection) : deepClone(collection);
+		this.rootCollections.push(collection);
+		this.rawRootCollections.push(raw);
+		this._registerRecursively(collection, raw);
+	}
+	_registerRecursively(collection, rawCollection) {
+		if (this.collectionsByTableName.has(getTableName(collection))) return;
+		const normalizedCollection = this.normalizeCollection(collection);
+		this.collectionsByTableName.set(getTableName(normalizedCollection), normalizedCollection);
+		this.rawCollectionsByTableName.set(getTableName(rawCollection), rawCollection);
+		if (normalizedCollection.slug) this.collectionsBySlug.set(normalizedCollection.slug, normalizedCollection);
+		if (rawCollection.slug) this.rawCollectionsBySlug.set(rawCollection.slug, rawCollection);
+		const subcollections = getSubcollections(normalizedCollection);
+		if (subcollections && subcollections.length > 0) subcollections.forEach((subCollection) => {
+			if (!subCollection) return;
+			this._registerRecursively(this.normalizeCollection({ ...subCollection }), deepClone(subCollection));
+		});
+	}
+	normalizeCollection(collection) {
+		const result = { ...collection };
+		{
+			const resolved = resolveDataSource(result, this.dataSources);
+			if (!result.dataSource) result.dataSource = resolved.key;
+			if (!result.engine) result.engine = resolved.engine;
+		}
+		const extractedRelations = this.extractRelationsFromProperties(result.properties);
+		const relResult = result;
+		const manualRelations = getDataSourceCapabilities(result.engine).supportsRelations ? relResult.relations ?? [] : [];
+		const mergedRelationsRaw = [...extractedRelations];
+		for (const manual of manualRelations) {
+			const name = manual.relationName;
+			if (!name) mergedRelationsRaw.push(manual);
+			else {
+				const existingIndex = mergedRelationsRaw.findIndex((r) => r.relationName === name);
+				if (existingIndex === -1) mergedRelationsRaw.push(manual);
+				else mergedRelationsRaw[existingIndex] = {
+					...manual,
+					...mergedRelationsRaw[existingIndex]
+				};
+			}
+		}
+		let mergedRelations = mergedRelationsRaw;
+		if (getDataSourceCapabilities(result.engine).supportsRelations) {
+			mergedRelations = mergedRelationsRaw.map((r) => {
+				try {
+					return sanitizeRelation(r, result, (slug) => this.get(slug));
+				} catch {
+					return r;
+				}
+			});
+			relResult.relations = mergedRelations;
+		}
+		result.properties = this.normalizeProperties(result.properties, mergedRelations);
+		if (!result.childCollections) {
+			const capabilities = getDataSourceCapabilities(result.engine);
+			const declaredSubcollections = getDeclaredSubcollections(result);
+			if (capabilities.supportsSubcollections && declaredSubcollections) result.childCollections = declaredSubcollections;
+			else if (capabilities.supportsRelations && relResult.relations) {
+				const manyRelations = relResult.relations.filter((r) => r.cardinality === "many");
+				if (manyRelations.length > 0) result.childCollections = () => manyRelations.map((r) => {
+					const target = r.target();
+					return r.overrides ? mergeDeep(target, r.overrides) : target;
+				});
+			}
+		}
+		return result;
+	}
+	/**
+	* Extract Relation[] from properties that have inline relation config (i.e. `target` is set).
+	* This allows developers to define relations directly on properties without a separate
+	* `relations[]` entry on the collection.
+	*/
+	extractRelationsFromProperties(properties) {
+		const relations = [];
+		for (const [key, property] of Object.entries(properties)) if (property.type === "relation") {
+			const relProp = property;
+			const target = relProp.target ?? relProp.relation?.target;
+			if (target) {
+				const relationName = relProp.relationName ?? relProp.relation?.relationName ?? key;
+				relations.push({
+					relationName,
+					target,
+					cardinality: relProp.cardinality ?? relProp.relation?.cardinality ?? "one",
+					direction: relProp.direction ?? relProp.relation?.direction ?? "owning",
+					inverseRelationName: relProp.inverseRelationName ?? relProp.relation?.inverseRelationName,
+					localKey: relProp.localKey ?? relProp.relation?.localKey,
+					foreignKeyOnTarget: relProp.foreignKeyOnTarget ?? relProp.relation?.foreignKeyOnTarget,
+					through: relProp.through ?? relProp.relation?.through,
+					joinPath: relProp.joinPath ?? relProp.relation?.joinPath,
+					onUpdate: relProp.onUpdate ?? relProp.relation?.onUpdate,
+					onDelete: relProp.onDelete ?? relProp.relation?.onDelete,
+					overrides: relProp.overrides ?? relProp.relation?.overrides
+				});
+			}
+		} else if (property.type === "map" && property.properties) relations.push(...this.extractRelationsFromProperties(property.properties));
+		return relations;
+	}
+	normalizeProperties(properties, relations) {
+		const newProperties = {};
+		for (const key in properties) newProperties[key] = this.normalizeProperty(key, properties[key], relations);
+		return newProperties;
+	}
+	normalizeProperty(key, property, relations) {
+		const newProperty = { ...property };
+		if (newProperty.type === "map" && newProperty.properties) newProperty.properties = this.normalizeProperties(newProperty.properties, relations);
+		else if (newProperty.type === "array") {
+			const arrayProp = newProperty;
+			if (arrayProp.of) if (Array.isArray(arrayProp.of)) arrayProp.of = arrayProp.of.map((p, i) => this.normalizeProperty(`${key}[${i}]`, p, relations));
+			else arrayProp.of = this.normalizeProperty(`${key}.of`, arrayProp.of, relations);
+			else if (arrayProp.oneOf && arrayProp.oneOf.properties) arrayProp.oneOf.properties = this.normalizeProperties(arrayProp.oneOf.properties, relations);
+		} else if ((newProperty.type === "string" || newProperty.type === "number") && newProperty.enum) {
+			const stringOrNumberProperty = newProperty;
+			if (typeof stringOrNumberProperty.enum === "object" && !Array.isArray(stringOrNumberProperty.enum)) stringOrNumberProperty.enum = enumToObjectEntries(stringOrNumberProperty.enum)?.filter((value) => value && (value.id || value.id === 0) && value.label) ?? [];
+		} else if (newProperty.type === "relation") {
+			const relationProperty = newProperty;
+			const name = relationProperty.relationName || key;
+			const relation = relations.find((r) => r.relationName === name);
+			if (relation) relationProperty.relation = relation;
+			else console.warn(`Could not find relation for property '${key}' with relationName: ${name}`);
+		}
+		return newProperty;
+	}
+	get(path) {
+		const bySlug = this.collectionsBySlug.get(path);
+		if (bySlug) return bySlug;
+		if (path.includes("-")) {
+			const normalized = path.replace(/-/g, "_");
+			const byNormalized = this.collectionsBySlug.get(normalized);
+			if (byNormalized) return byNormalized;
+		}
+		return this.collectionsByTableName.get(path);
+	}
+	/**
+	* Gets the pristine, un-normalized collection exactly as it was provided.
+	* Useful for the AST editor so it doesn't accidentally serialize injected metadata back to disk.
+	*/
+	getRaw(path) {
+		const bySlug = this.rawCollectionsBySlug.get(path);
+		if (bySlug) return bySlug;
+		if (path.includes("-")) {
+			const normalized = path.replace(/-/g, "_");
+			const byNormalized = this.rawCollectionsBySlug.get(normalized);
+			if (byNormalized) return byNormalized;
+		}
+		return this.rawCollectionsByTableName.get(path);
+	}
+	/**
+	* Get collection by resolving multi-segment paths through relations
+	* e.g., "authors/70/posts" resolves to the posts collection
+	*/
+	getCollectionByPath(collectionPath) {
+		if (!collectionPath.includes("/")) return this.get(collectionPath);
+		const pathSegments = collectionPath.split("/").filter((p) => p);
+		if (pathSegments.length < 3 || pathSegments.length % 2 === 0) throw new Error(`Invalid relation path: ${collectionPath}. Expected format: collection/id/relation or collection/id/relation/id/relation`);
+		const rootCollectionPath = pathSegments[0];
+		let currentCollection = this.get(rootCollectionPath);
+		if (!currentCollection) throw new Error(`Root collection not found: ${rootCollectionPath}`);
+		for (let i = 2; i < pathSegments.length; i += 2) {
+			const relationKey = pathSegments[i];
+			if (!getDataSourceCapabilities(currentCollection.engine).supportsRelations) throw new Error(`Relation path navigation requires a collection that supports relations, but '${currentCollection.slug}' uses engine '${currentCollection.engine}'`);
+			const relation = findRelation(resolveCollectionRelations(currentCollection), relationKey);
+			if (!relation) throw new Error(`Relation '${relationKey}' not found in collection '${currentCollection.slug}'`);
+			const target = relation.target();
+			const targetRelationKey = relation.relationName || target.slug;
+			const targetSlug = relation.overrides?.slug ?? targetRelationKey;
+			currentCollection = this.get(targetSlug) || this.normalizeCollection(target);
+			if (i + 1 < pathSegments.length) {}
+		}
+		return currentCollection;
+	}
+	getCollections() {
+		if (!this.cachedCollectionsList) this.cachedCollectionsList = Array.from(this.collectionsByTableName.values());
+		return this.cachedCollectionsList;
+	}
+	getRawCollections() {
+		if (!this.cachedRawCollectionsList) this.cachedRawCollectionsList = Array.from(this.rawCollectionsByTableName.values());
+		return this.cachedRawCollectionsList;
+	}
+	/**
+	* Resolves a multi-segment path like "products/123/locales" and returns
+	* information about the collections and entity IDs along the path
+	*/
+	resolvePathToCollections(path) {
+		const pathSegments = path.split("/").filter((p) => p);
+		if (pathSegments.length === 0) throw new Error(`Invalid path: ${path}`);
+		if (pathSegments.length % 2 !== 1) throw new Error(`Invalid collection path: ${path}. It must have an odd number of segments.`);
+		const collections = [];
+		const entityIds = [];
+		let currentCollection = this.get(pathSegments[0]);
+		if (!currentCollection) throw new Error(`Unknown collection path or slug: ${pathSegments[0]}`);
+		collections.push(currentCollection);
+		for (let i = 1; i < pathSegments.length; i += 2) {
+			const entityId = pathSegments[i];
+			entityIds.push(entityId);
+			if (i + 1 < pathSegments.length) {
+				const subcollectionSlug = pathSegments[i + 1];
+				const subcollections = getSubcollections(currentCollection);
+				if (!subcollections || subcollections.length === 0) throw new Error(`No subcollections found for ${currentCollection.slug} in path: ${path}`);
+				const subcollection = subcollections.find((c) => c.slug === subcollectionSlug);
+				if (!subcollection) throw new Error(`Subcollection '${subcollectionSlug}' not found in ${currentCollection.slug}`);
+				currentCollection = this.get(subcollection.slug) || this.normalizeCollection(subcollection);
+				collections.push(currentCollection);
+			}
+		}
+		return {
+			collections,
+			entityIds,
+			finalCollection: currentCollection
+		};
+	}
+};
+//#endregion
+//#region ../common/src/data/query_builder.ts
+var QueryBuilder = class {
+	collection;
+	params = { where: {} };
+	constructor(collection) {
+		this.collection = collection;
+	}
+	where(columnOrCondition, operator, value) {
+		if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
+			this.params.logical = columnOrCondition;
+			return this;
+		}
+		if (!this.params.where) this.params.where = {};
+		const column = columnOrCondition;
+		const condition = [operator, value];
+		const existing = this.params.where[column];
+		if (existing === void 0) this.params.where[column] = condition;
+		else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) this.params.where[column].push(condition);
+		else {
+			let firstCondition;
+			if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") firstCondition = existing;
+			else firstCondition = ["==", existing];
+			this.params.where[column] = [firstCondition, condition];
+		}
+		return this;
+	}
+	/**
+	* Order the results by a specific column.
+	* @example
+	* client.collection('users').orderBy('createdAt', 'desc').find()
+	*/
+	orderBy(column, direction = "asc") {
+		this.params.orderBy = [column, direction];
+		return this;
+	}
+	/**
+	* Limit the number of results returned.
+	*/
+	limit(count) {
+		this.params.limit = count;
+		return this;
+	}
+	/**
+	* Skip the first N results.
+	*/
+	offset(count) {
+		this.params.offset = count;
+		return this;
+	}
+	/**
+	* Set a free-text search string if supported by the backend.
+	*/
+	search(searchString) {
+		this.params.searchString = searchString;
+		return this;
+	}
+	/**
+	* Include related entities in the response.
+	* Relations will be populated with full entity data instead of just IDs.
+	*
+	* @param relations - Relation names to include, or "*" for all.
+	* @example
+	* // Include specific relations
+	* client.data.posts.include("tags", "author").find()
+	*
+	* // Include all relations
+	* client.data.posts.include("*").find()
+	*/
+	include(...relations) {
+		this.params.include = relations;
+		return this;
+	}
+	/**
+	* Execute the find query and return the results.
+	*/
+	async find() {
+		return this.collection.find(this.params);
+	}
+	/**
+	* Listen to realtime updates matching this query.
+	*/
+	listen(onUpdate, onError) {
+		if (!this.collection.listen) throw new Error("Listen is only available when RebaseClient is configured with a websocketUrl.");
+		return this.collection.listen(this.params, onUpdate, onError);
+	}
+};
+//#endregion
+//#region ../common/src/data/filter-dialect.ts
+/**
+* REST wire-format adapter for the unified filter system.
+*
+* This module is the ONLY code in the entire codebase that knows about
+* PostgREST-style dot-syntax strings (`eq.active`, `gt.18`, `in.(a,b)`).
+* Everything else speaks `FilterValues` exclusively.
+*
+* Wire-format values are always strings — the wire format carries no type
+* metadata, so type coercion is the responsibility of the server-side data
+* driver which has access to the collection schema.
+*
+* Commas inside list values are backslash-escaped (`\,`), and literal
+* backslashes are escaped as `\\`.
+*
+* @module
+*/
+/**
+* Unescape a single list item from the wire format.
+* `\\` → `\`, `\,` → `,`
+*/
+function unescapeListItem(value) {
+	let result = "";
+	for (let i = 0; i < value.length; i++) if (value[i] === "\\" && i + 1 < value.length) {
+		result += value[i + 1];
+		i++;
+	} else result += value[i];
+	return result;
+}
+/**
+* Split a parenthesized list string on unescaped commas.
+* Input is the content between `(` and `)`.
+*
+* @example
+* splitListItems("admin,editor")          // ["admin", "editor"]
+* splitListItems("hello\\, world,foo")    // ["hello, world", "foo"]
+*/
+function splitListItems(inner) {
+	const items = [];
+	let current = "";
+	for (let i = 0; i < inner.length; i++) if (inner[i] === "\\" && i + 1 < inner.length) {
+		current += inner[i] + inner[i + 1];
+		i++;
+	} else if (inner[i] === ",") {
+		items.push(unescapeListItem(current));
+		current = "";
+	} else current += inner[i];
+	items.push(unescapeListItem(current));
+	return items;
+}
+var REST_OP_LOOKUP = REST_TO_CANONICAL;
+/**
+* Parse a single PostgREST dot-string into a `[WhereFilterOp, unknown]` tuple.
+*
+* All values are returned as strings — the wire format carries no type
+* metadata, so coercion is the data driver's responsibility.
+*
+* If the string doesn't match a known operator prefix, it falls back to
+* `["==", originalString]` (treating the whole string as an equality value).
+* This intentional defense handles values like `"user@host.com"` or
+* `"1.2.3"` that happen to contain dots.
+*/
+function deserializeSingle(raw) {
+	const dotIndex = raw.indexOf(".");
+	if (dotIndex === -1) return ["==", raw];
+	const prefix = raw.substring(0, dotIndex);
+	const rest = raw.substring(dotIndex + 1);
+	const canonicalOp = REST_OP_LOOKUP[prefix];
+	if (!canonicalOp) return ["==", raw];
+	if (NULL_OPS.has(canonicalOp)) return [canonicalOp, null];
+	if (rest.startsWith("(") && rest.endsWith(")")) return [canonicalOp, splitListItems(rest.slice(1, -1))];
+	return [canonicalOp, rest];
+}
+/**
+* Convert a PostgREST-style querystring record to `FilterValues`.
+*
+* - String values are parsed as single conditions.
+* - String arrays (repeated query params) become multiple conditions on the same field.
+*
+* @example
+* deserializeFilter({ status: "eq.active" })
+* // → { status: ["==", "active"] }
+*
+* deserializeFilter({ age: ["gte.18", "lt.65"] })
+* // → { age: [[">=", "18"], ["<", "65"]] }
+*/
+function deserializeFilter(query) {
+	const result = {};
+	for (const [field, raw] of Object.entries(query)) {
+		if (raw === void 0) continue;
+		if (Array.isArray(raw) && raw.length === 2 && typeof raw[0] === "string" && toCanonicalOp(raw[0]) === raw[0]) {
+			result[field] = raw;
+			continue;
+		}
+		if (Array.isArray(raw)) {
+			if (raw.length === 0) continue;
+			if (Array.isArray(raw[0]) && raw[0].length === 2 && typeof raw[0][0] === "string" && toCanonicalOp(raw[0][0]) === raw[0][0]) {
+				result[field] = raw;
+				continue;
+			}
+			if (raw.length === 1) result[field] = typeof raw[0] === "string" ? deserializeSingle(raw[0]) : ["==", raw[0]];
+			else if (typeof raw[0] === "string" && raw[0].includes(".")) result[field] = raw.map((r) => typeof r === "string" ? deserializeSingle(r) : ["==", r]);
+			else result[field] = ["in", raw];
+		} else if (typeof raw === "string") result[field] = deserializeSingle(raw);
+		else result[field] = ["==", raw];
+	}
+	return result;
+}
+//#endregion
+//#region ../common/src/data/buildRebaseData.ts
+function createPrimaryKeyResolver(options) {
+	const cache = /* @__PURE__ */ new Map();
+	const warned = /* @__PURE__ */ new Set();
+	return function primaryKeysFor(slug) {
+		const cached = cache.get(slug);
+		if (cached) return cached;
+		const collection = options?.resolveCollection?.(slug);
+		if (!collection) return [];
+		const keys = resolvePrimaryKeys(collection);
+		if (keys.length > 0) {
+			cache.set(slug, keys);
+			return keys;
+		}
+		if (!warned.has(slug)) {
+			warned.add(slug);
+			console.warn(`[rebase] Collection '${slug}' declares no primary key, so its rows have no address: detail links, caching and relations will not work for it. Mark the key property with \`isId\` in its collection config — the server logs which column to mark at boot, if its schema knows the key.`);
+		}
+		return keys;
+	};
+}
+/**
+* Give a flat row the Entity view-model the admin renders.
+*
+* The address is *derived here* — it is not a column, and the row it came from
+* does not contain one. Rows carry exactly what the table has, with the types
+* Postgres returned; the id is this layer's invention, and this is the only
+* place it is minted.
+*
+* `primaryKeys` empty falls back to a literal `id` on the row: drivers other
+* than postgres still serve rows with one, and this keeps them working.
+*/
+function rowToEntity(row, slug, primaryKeys = []) {
+	return {
+		id: primaryKeys.length > 0 ? buildCompositeId(row, primaryKeys) : row.id,
+		path: slug,
+		values: row
+	};
+}
+function createDriverAccessor(driver, slug, getPks = () => []) {
+	const accessor = {
+		async find(params) {
+			const filter = params?.where ? deserializeFilter(params.where) : void 0;
+			const limit = params?.limit ?? 20;
+			const offset = params?.offset ?? 0;
+			const fetchService = driver.restFetchService;
+			const rows = fetchService && params?.include && params.include.length > 0 ? await fetchService.fetchCollectionForRest(slug, {
+				filter,
+				limit: params?.limit,
+				offset: params?.offset,
+				orderBy: params?.orderBy?.[0],
+				order: params?.orderBy?.[1],
+				searchString: params?.searchString
+			}, params.include) : await driver.fetchCollection({
+				path: slug,
+				limit: params?.limit,
+				offset: params?.offset,
+				filter,
+				orderBy: params?.orderBy?.[0],
+				order: params?.orderBy?.[1],
+				searchString: params?.searchString
+			});
+			let total = rows.length + offset;
+			let hasMore = rows.length >= limit;
+			if (driver.count) {
+				total = await driver.count({
+					path: slug,
+					filter
+				});
+				hasMore = offset + rows.length < total;
+			}
+			return {
+				data: rows.map((row) => rowToEntity(row, slug, getPks())),
+				meta: {
+					total,
+					limit,
+					offset,
+					hasMore
+				}
+			};
+		},
+		async findById(id) {
+			const row = await driver.fetchOne({
+				path: slug,
+				id
+			});
+			return row ? rowToEntity(row, slug, getPks()) : void 0;
+		},
+		async create(data, id) {
+			return rowToEntity(await driver.save({
+				path: slug,
+				values: data,
+				id,
+				status: "new"
+			}), slug, getPks());
+		},
+		createMany: driver.saveMany ? async (data, options) => {
+			return (await driver.saveMany({
+				path: slug,
+				rows: data,
+				upsert: options?.upsert
+			})).map((row) => rowToEntity(row, slug, getPks()));
+		} : void 0,
+		async update(id, data) {
+			return rowToEntity(await driver.save({
+				path: slug,
+				values: data,
+				id,
+				status: "existing"
+			}), slug, getPks());
+		},
+		async delete(id) {
+			return driver.delete({ row: {
+				id,
+				path: slug,
+				values: {}
+			} });
+		},
+		count: driver.count ? async (params) => {
+			const filter = params?.where ? deserializeFilter(params.where) : void 0;
+			return driver.count({
+				path: slug,
+				filter
+			});
+		} : void 0,
+		listen: driver.listenCollection ? (params, onUpdate, onError) => {
+			const limit = params?.limit ?? 20;
+			const offset = params?.offset ?? 0;
+			return driver.listenCollection({
+				path: slug,
+				limit: params?.limit,
+				offset: params?.offset,
+				filter: params?.where,
+				orderBy: params?.orderBy?.[0],
+				order: params?.orderBy?.[1],
+				searchString: params?.searchString,
+				onUpdate: (entities) => {
+					onUpdate({
+						data: entities.map((row) => rowToEntity(row, slug, getPks())),
+						meta: {
+							total: entities.length,
+							limit,
+							offset,
+							hasMore: entities.length >= limit
+						}
+					});
+				},
+				onError
+			});
+		} : void 0,
+		listenById: driver.listenOne ? (id, onUpdate, onError) => {
+			return driver.listenOne({
+				path: slug,
+				id,
+				onUpdate: (entity) => onUpdate(entity ? rowToEntity(entity, slug, getPks()) : void 0),
+				onError
+			});
+		} : void 0,
+		where(columnOrCondition, operator, value) {
+			const builder = new QueryBuilder(accessor);
+			if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+			return builder.where(columnOrCondition, operator, value);
+		},
+		orderBy(column, ascending) {
+			return new QueryBuilder(accessor).orderBy(column, ascending);
+		},
+		limit(count) {
+			return new QueryBuilder(accessor).limit(count);
+		},
+		offset(count) {
+			return new QueryBuilder(accessor).offset(count);
+		},
+		search(searchString) {
+			return new QueryBuilder(accessor).search(searchString);
+		},
+		include(...relations) {
+			return new QueryBuilder(accessor).include(...relations);
+		}
+	};
+	return accessor;
+}
+/**
+* Build a `RebaseData` object from a `DataDriver` using JavaScript Proxy.
+*
+* This is the key bridge: any property access like `data.products` returns
+* a `CollectionAccessor` backed by the underlying DataDriver, without
+* needing per-collection code generation.
+*
+* @example
+* const data = buildRebaseData(driver);
+* await data.products.create({ name: "Camera", price: 299 });
+* const { data: items } = await data.products.find({ where: { status: ["==", "published"] } });
+*/
+function buildRebaseData(driver, options) {
+	const cache = /* @__PURE__ */ new Map();
+	const primaryKeysFor = createPrimaryKeyResolver(options);
+	function getAccessor(slug) {
+		let accessor = cache.get(slug);
+		if (!accessor) {
+			accessor = createDriverAccessor(driver, slug, () => primaryKeysFor(slug));
+			cache.set(slug, accessor);
+		}
+		return accessor;
+	}
+	return new Proxy({ collection: getAccessor }, { get(_target, prop) {
+		if (prop === "collection") return getAccessor;
+		if (typeof prop === "symbol") return void 0;
+		if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
+		return getAccessor(toSnakeCase(prop));
+	} });
+}
+/**
+* Unwrap a Entity back into the flat row it was built from. `rowToEntity` keeps
+* the row untouched under `.values` and derives `.id` alongside it, so dropping
+* the wrapper is the whole operation — the address was never part of the row.
+*/
+function entityToRow(entity) {
+	return entity.values;
+}
+/**
+* Fluent query builder for the flat SDK data layer. Mirrors {@link QueryBuilder}
+* but resolves to `FindResult<M>` (flat rows) instead of Entity-wrapped
+* `FindResponse<M>`.
+*/
+var SdkQueryBuilder = class {
+	client;
+	params = { where: {} };
+	constructor(client) {
+		this.client = client;
+	}
+	where(columnOrCondition, operator, value) {
+		if (typeof columnOrCondition === "object" && columnOrCondition !== null && "type" in columnOrCondition) {
+			this.params.logical = columnOrCondition;
+			return this;
+		}
+		if (!this.params.where) this.params.where = {};
+		const column = columnOrCondition;
+		const condition = [operator, value];
+		const existing = this.params.where[column];
+		if (existing === void 0) this.params.where[column] = condition;
+		else if (Array.isArray(existing) && existing.length > 0 && Array.isArray(existing[0])) this.params.where[column].push(condition);
+		else {
+			let firstCondition;
+			if (Array.isArray(existing) && existing.length === 2 && typeof existing[0] === "string") firstCondition = existing;
+			else firstCondition = ["==", existing];
+			this.params.where[column] = [firstCondition, condition];
+		}
+		return this;
+	}
+	orderBy(column, direction = "asc") {
+		this.params.orderBy = [column, direction];
+		return this;
+	}
+	limit(count) {
+		this.params.limit = count;
+		return this;
+	}
+	offset(count) {
+		this.params.offset = count;
+		return this;
+	}
+	search(searchString) {
+		this.params.searchString = searchString;
+		return this;
+	}
+	include(...relations) {
+		this.params.include = relations;
+		return this;
+	}
+	async find() {
+		return this.client.find(this.params);
+	}
+	async count() {
+		return this.client.count ? this.client.count(this.params) : 0;
+	}
+	listen(onUpdate, onError) {
+		if (!this.client.listen) throw new Error("Listen is only available when the driver supports realtime.");
+		return this.client.listen(this.params, onUpdate, onError);
+	}
+};
+/**
+* Wrap a Entity-shaped {@link CollectionAccessor} into a flat
+* {@link SDKCollectionClient}. Every returned record is unwrapped to a flat row
+* so the backend SDK is byte-for-byte the same shape as the frontend client.
+*/
+function toSdkCollectionClient(snap) {
+	const client = {
+		async find(params) {
+			const res = await snap.find(params);
+			return {
+				data: res.data.map(entityToRow),
+				meta: res.meta
+			};
+		},
+		async findById(id) {
+			const s = await snap.findById(id);
+			return s ? entityToRow(s) : void 0;
+		},
+		async create(data, id) {
+			return entityToRow(await snap.create(data, id));
+		},
+		async createMany(data, options) {
+			if (!Array.isArray(data)) throw new TypeError("createMany expects an array of records.");
+			if (data.length === 0) return [];
+			if (!snap.createMany) throw new Error("Bulk writes are not supported by this collection's data source. Fall back to create() per record.");
+			return (await snap.createMany(data, options)).map(entityToRow);
+		},
+		async update(id, data) {
+			return entityToRow(await snap.update(id, data));
+		},
+		delete(id) {
+			return snap.delete(id);
+		},
+		count: snap.count ? (params) => snap.count(params) : void 0,
+		listen: snap.listen ? (params, onUpdate, onError) => snap.listen(params, (res) => onUpdate({
+			data: res.data.map(entityToRow),
+			meta: res.meta
+		}), onError) : void 0,
+		listenById: snap.listenById ? (id, onUpdate, onError) => snap.listenById(id, (s) => onUpdate(s ? entityToRow(s) : void 0), onError) : void 0,
+		where(columnOrCondition, operator, value) {
+			const builder = new SdkQueryBuilder(client);
+			if (typeof columnOrCondition === "object") return builder.where(columnOrCondition);
+			return builder.where(columnOrCondition, operator, value);
+		},
+		orderBy: (column, direction) => new SdkQueryBuilder(client).orderBy(column, direction),
+		limit: (count) => new SdkQueryBuilder(client).limit(count),
+		offset: (count) => new SdkQueryBuilder(client).offset(count),
+		search: (searchString) => new SdkQueryBuilder(client).search(searchString),
+		include: (...relations) => new SdkQueryBuilder(client).include(...relations)
+	};
+	return client;
+}
+/**
+* Wrap a Entity-shaped {@link RebaseData} into a flat {@link RebaseSdkData}.
+*
+* Every collection accessor is adapted to return flat rows. Use this to derive
+* the flat SDK data layer (`context.data`) from an existing Entity data layer
+* — e.g. the admin routes its Entity data via `useData()` and exposes the
+* same routing as flat `context.data` for callbacks by wrapping it here.
+*/
+function wrapAsSdkData(entityData) {
+	const cache = /* @__PURE__ */ new Map();
+	function getAccessor(slug) {
+		let accessor = cache.get(slug);
+		if (!accessor) {
+			accessor = toSdkCollectionClient(entityData.collection(slug));
+			cache.set(slug, accessor);
+		}
+		return accessor;
+	}
+	return new Proxy({ collection: getAccessor }, { get(_target, prop) {
+		if (prop === "collection") return getAccessor;
+		if (typeof prop === "symbol") return void 0;
+		if (prop === "then" || prop === "toJSON" || prop === "$$typeof") return void 0;
+		return getAccessor(toSnakeCase(prop));
+	} });
+}
+/**
+* Build a flat {@link RebaseSdkData} from a `DataDriver`.
+*
+* This is the developer-facing SDK data layer used by backend framework
+* callbacks & scripts (`context.data` / `rebase.data`). It returns flat rows —
+* identical in shape to the frontend SDK client — so the API is symmetric
+* across front and back. The admin CMS uses {@link buildRebaseData} (Entity).
+*/
+function buildSdkData(driver) {
+	return wrapAsSdkData(buildRebaseData(driver));
+}
+//#endregion
+//#region ../common/src/table-classification.ts
+/** Schemas that are always considered Rebase-internal. */
+var REBASE_INTERNAL_SCHEMAS = ["rebase", "auth"];
+/** Table-name prefixes that mark a table as Rebase-internal regardless of schema. */
+var REBASE_INTERNAL_PREFIXES = [
+	"_rebase_",
+	"_auth_",
+	"drizzle_"
+];
+/**
+* Synchronously classify a table based on naming conventions.
+*
+* @param tableName  - The unqualified name of the table.
+* @param schemaName - The schema the table belongs to (e.g. `"public"`, `"rebase"`).
+* @returns `"rebase-internal"` when the table belongs to a reserved schema or
+*          carries a reserved prefix; `"user"` otherwise.
+*
+* @remarks
+* Junction-table detection requires an async database query and is therefore
+* **not** handled by this function. Use {@link detectJunctionTables} to obtain
+* the set of junction tables, then reclassify as needed.
+*/
+function classifyTable(tableName, schemaName) {
+	if (REBASE_INTERNAL_SCHEMAS.includes(schemaName) || REBASE_INTERNAL_PREFIXES.some((prefix) => tableName.startsWith(prefix))) return "rebase-internal";
+	return "user";
+}
+/** SQL query that detects junction tables in the `public` schema. */
+var JUNCTION_TABLES_SQL = `
+  SELECT t.table_name
+  FROM information_schema.tables t
+  WHERE t.table_schema = 'public'
+    AND t.table_type = 'BASE TABLE'
+    AND NOT EXISTS (
+      SELECT 1
+      FROM information_schema.columns c
+      WHERE c.table_schema = t.table_schema
+        AND c.table_name = t.table_name
+        AND c.column_name NOT IN (
+          SELECT kcu.column_name
+          FROM information_schema.key_column_usage kcu
+          JOIN information_schema.table_constraints tc
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND kcu.table_schema = t.table_schema
+            AND kcu.table_name = t.table_name
+        )
+    )
+`;
+/**
+* Asynchronously detect junction (link) tables in the `public` schema.
+*
+* A junction table is defined as a table where **every** column participates in
+* at least one foreign-key constraint.
+*
+* @param executeSql - A callback that executes a raw SQL string and returns the
+*                     resulting rows.
+* @returns A `Set` containing the names of all detected junction tables.
+*/
+async function detectJunctionTables(executeSql) {
+	const rows = await executeSql(JUNCTION_TABLES_SQL);
+	const junctionTables = /* @__PURE__ */ new Set();
+	for (const row of rows) if (typeof row.table_name === "string") junctionTables.add(row.table_name);
+	return junctionTables;
+}
+//#endregion
+export { DEFAULT_ONE_OF_TYPE as A, createRelationRefWithData as C, mergeDeep as D, getPolicyNamesForRule as E, camelCase as O, createRelationRef as S, updateDateAutoValues as T, getTableVarName as _, getJunctionCollectionConfig as a, getDeclaredPrimaryKeys as b, getEffectiveSecurityRules as c, securityRuleToConditions as d, findAnonymousGrants as f, getTableName as g, getEnumVarName as h, CollectionRegistry as i, DEFAULT_ONE_OF_VALUE as j, toSnakeCase as k, buildPropertyCallbacks as l, getColumnName as m, detectJunctionTables as n, getJunctionSecurityRules as o, findRelation as p, buildSdkData as r, resolveJunctionSpecs as s, classifyTable as t, policyToPostgres as u, resolveCollectionRelations as v, normalizeToEntityRelation as w, parseIdValues as x, buildCompositeId as y };
+
+//# sourceMappingURL=src-DmsRg8MR.js.map