equipped 5.2.8 → 5.3.0-alpha.0

package/dist/cjs/orm/adapters/postgresql/index.cjs

@@ -0,0 +1,4114 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/errors/equippedError.ts
+var EquippedError;
+var init_equippedError = __esm({
+  "src/errors/equippedError.ts"() {
+    "use strict";
+    EquippedError = class extends Error {
+      constructor(message, context, cause) {
+        super(message, { cause });
+        this.message = message;
+        this.context = context;
+        this.cause = cause;
+      }
+    };
+  }
+});
+
+// src/errors/requestError.ts
+var init_requestError = __esm({
+  "src/errors/requestError.ts"() {
+    "use strict";
+  }
+});
+
+// src/instance/hooks.ts
+function registerHook(hooks, record) {
+  for (const dep of record.after) {
+    if (!hooks.some((h) => h.class === dep)) {
+      const depName = dep.name || "unknown";
+      const ownerName = record.class?.name || "anonymous";
+      throw new Error(`Missing dependency: ${ownerName} declares after: [${depName}], but ${depName} is not registered`);
+    }
+  }
+  if (record.class) {
+    const tentative = [...hooks, record];
+    detectCycle(tentative);
+  }
+  hooks.push(record);
+}
+function detectCycle(hooks) {
+  const classToAfter = /* @__PURE__ */ new Map();
+  for (const h of hooks) {
+    if (!h.class) continue;
+    const existing = classToAfter.get(h.class);
+    if (existing) {
+      for (const dep of h.after) {
+        if (!existing.includes(dep)) existing.push(dep);
+      }
+    } else {
+      classToAfter.set(h.class, [...h.after]);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  function visit(cls, path) {
+    if (stack.has(cls)) {
+      const cycleStart = path.indexOf(cls);
+      const cycle = [...path.slice(cycleStart), cls];
+      const names = cycle.map((c) => c.name || "unknown");
+      throw new Error(`Cycle detected: ${names.join(" \u2192 ")}`);
+    }
+    if (visited.has(cls)) return;
+    stack.add(cls);
+    path.push(cls);
+    for (const dep of classToAfter.get(cls) ?? []) {
+      visit(dep, path);
+    }
+    path.pop();
+    stack.delete(cls);
+    visited.add(cls);
+  }
+  for (const cls of classToAfter.keys()) {
+    visit(cls, []);
+  }
+}
+function resolveHookDAG(hooks, invert = false) {
+  if (hooks.length === 0) return [];
+  const classToHooks = /* @__PURE__ */ new Map();
+  const anonymous = [];
+  for (const h of hooks) {
+    if (h.class) {
+      const list = classToHooks.get(h.class);
+      if (list) list.push(h);
+      else classToHooks.set(h.class, [h]);
+    } else {
+      anonymous.push(h);
+    }
+  }
+  const classes = [...classToHooks.keys()];
+  const inDegree = /* @__PURE__ */ new Map();
+  const graph = /* @__PURE__ */ new Map();
+  for (const cls of classes) {
+    inDegree.set(cls, 0);
+    graph.set(cls, []);
+  }
+  for (const h of hooks) {
+    if (!h.class) continue;
+    for (const dep of h.after) {
+      const [from, to] = invert ? [h.class, dep] : [dep, h.class];
+      const edges = graph.get(from);
+      if (!edges.includes(to)) {
+        edges.push(to);
+        inDegree.set(to, inDegree.get(to) + 1);
+      }
+    }
+  }
+  const layers = [];
+  let queue = classes.filter((c) => inDegree.get(c) === 0);
+  while (queue.length > 0) {
+    const layer = [];
+    const next = [];
+    for (const cls of queue) {
+      layer.push(...classToHooks.get(cls) ?? []);
+    }
+    layers.push(layer);
+    for (const cls of queue) {
+      for (const neighbor of graph.get(cls) ?? []) {
+        const d = inDegree.get(neighbor) - 1;
+        inDegree.set(neighbor, d);
+        if (d === 0) next.push(neighbor);
+      }
+    }
+    queue = next;
+  }
+  if (anonymous.length > 0) {
+    const anonWithDeps = anonymous.filter((h) => h.after.length > 0);
+    const anonWithoutDeps = anonymous.filter((h) => h.after.length === 0);
+    if (anonWithDeps.length > 0) {
+      let maxLayer = -1;
+      for (const h of anonWithDeps) {
+        for (const dep of h.after) {
+          const depLayer = layers.findIndex((l) => l.some((r) => r.class === dep));
+          if (depLayer > maxLayer) maxLayer = depLayer;
+        }
+      }
+      const insertAt = maxLayer + 1;
+      if (insertAt < layers.length) {
+        layers[insertAt].push(...anonWithDeps);
+      } else {
+        layers.push(anonWithDeps);
+      }
+    }
+    if (anonWithoutDeps.length > 0) {
+      if (layers.length > 0) {
+        layers[layers.length - 1].push(...anonWithoutDeps);
+      } else {
+        layers.push(anonWithoutDeps);
+      }
+    }
+  }
+  return layers;
+}
+async function runHooks(hooks, onError = (error) => {
+  throw error;
+}, invert = false) {
+  const layers = resolveHookDAG(hooks, invert);
+  for (const layer of layers)
+    await Promise.all(
+      layer.map(async (h) => {
+        try {
+          if (typeof h.cb === "function") return await h.cb();
+          return await h.cb;
+        } catch (error) {
+          return onError(error instanceof Error ? error : new Error(`${error}`));
+        }
+      })
+    );
+}
+var init_hooks = __esm({
+  "src/instance/hooks.ts"() {
+    "use strict";
+    if (void 0) {
+      const { describe, test, expect } = void 0;
+      class A {
+      }
+      class B {
+      }
+      class C {
+      }
+      class D {
+      }
+      const noop = () => {
+      };
+      describe("registerHook", () => {
+        test("registers a hook with no dependencies", () => {
+          const hooks = [];
+          registerHook(hooks, { cb: noop, class: A, after: [] });
+          expect(hooks).toHaveLength(1);
+        });
+        test("throws on missing dependency", () => {
+          const hooks = [];
+          expect(() => registerHook(hooks, { cb: noop, class: B, after: [A] })).toThrow(/Missing dependency.*B.*A/);
+        });
+        test("throws on cycle: A\u2192B\u2192A", () => {
+          const hooks = [];
+          registerHook(hooks, { cb: noop, class: A, after: [] });
+          registerHook(hooks, { cb: noop, class: B, after: [A] });
+          expect(() => registerHook(hooks, { cb: noop, class: A, after: [B] })).toThrow(/Cycle detected/);
+        });
+        test("throws on transitive cycle: A\u2192B\u2192C\u2192A", () => {
+          const hooks = [];
+          registerHook(hooks, { cb: noop, class: A, after: [] });
+          registerHook(hooks, { cb: noop, class: B, after: [A] });
+          registerHook(hooks, { cb: noop, class: C, after: [B] });
+          expect(() => registerHook(hooks, { cb: noop, class: A, after: [C] })).toThrow(/Cycle detected/);
+        });
+        test("allows anonymous hooks with dependencies", () => {
+          const hooks = [];
+          registerHook(hooks, { cb: noop, class: A, after: [] });
+          registerHook(hooks, { cb: noop, after: [A] });
+          expect(hooks).toHaveLength(2);
+        });
+        test("anonymous hook throws on missing dependency", () => {
+          const hooks = [];
+          expect(() => registerHook(hooks, { cb: noop, after: [A] })).toThrow(/Missing dependency.*anonymous.*A/);
+        });
+      });
+      describe("resolveHookDAG", () => {
+        test("linear chain: A \u2192 B \u2192 C", () => {
+          const hooks = [
+            { cb: noop, class: A, after: [] },
+            { cb: noop, class: B, after: [A] },
+            { cb: noop, class: C, after: [B] }
+          ];
+          const layers = resolveHookDAG(hooks);
+          expect(layers).toHaveLength(3);
+          expect(layers[0].every((h) => h.class === A)).toBe(true);
+          expect(layers[1].every((h) => h.class === B)).toBe(true);
+          expect(layers[2].every((h) => h.class === C)).toBe(true);
+        });
+        test("fan-out: A \u2192 B, A \u2192 C (B and C are parallel)", () => {
+          const hooks = [
+            { cb: noop, class: A, after: [] },
+            { cb: noop, class: B, after: [A] },
+            { cb: noop, class: C, after: [A] }
+          ];
+          const layers = resolveHookDAG(hooks);
+          expect(layers).toHaveLength(2);
+          expect(layers[0].every((h) => h.class === A)).toBe(true);
+          const secondClasses = layers[1].map((h) => h.class);
+          expect(secondClasses).toContain(B);
+          expect(secondClasses).toContain(C);
+        });
+        test("fan-in: B \u2192 D, C \u2192 D", () => {
+          const hooks = [
+            { cb: noop, class: B, after: [] },
+            { cb: noop, class: C, after: [] },
+            { cb: noop, class: D, after: [B, C] }
+          ];
+          const layers = resolveHookDAG(hooks);
+          expect(layers).toHaveLength(2);
+          const firstClasses = layers[0].map((h) => h.class);
+          expect(firstClasses).toContain(B);
+          expect(firstClasses).toContain(C);
+          expect(layers[1].every((h) => h.class === D)).toBe(true);
+        });
+        test("diamond: A \u2192 B, A \u2192 C, B \u2192 D, C \u2192 D", () => {
+          const hooks = [
+            { cb: noop, class: A, after: [] },
+            { cb: noop, class: B, after: [A] },
+            { cb: noop, class: C, after: [A] },
+            { cb: noop, class: D, after: [B, C] }
+          ];
+          const layers = resolveHookDAG(hooks);
+          expect(layers).toHaveLength(3);
+          expect(layers[0][0].class).toBe(A);
+          const midClasses = layers[1].map((h) => h.class);
+          expect(midClasses).toContain(B);
+          expect(midClasses).toContain(C);
+          expect(layers[2][0].class).toBe(D);
+        });
+        test("close-event inversion reverses the graph", () => {
+          const hooks = [
+            { cb: noop, class: A, after: [] },
+            { cb: noop, class: B, after: [A] },
+            { cb: noop, class: C, after: [B] }
+          ];
+          const layers = resolveHookDAG(hooks, true);
+          expect(layers).toHaveLength(3);
+          expect(layers[0].every((h) => h.class === C)).toBe(true);
+          expect(layers[1].every((h) => h.class === B)).toBe(true);
+          expect(layers[2].every((h) => h.class === A)).toBe(true);
+        });
+        test("close inversion: fan-out becomes fan-in", () => {
+          const hooks = [
+            { cb: noop, class: A, after: [] },
+            { cb: noop, class: B, after: [A] },
+            { cb: noop, class: C, after: [A] }
+          ];
+          const layers = resolveHookDAG(hooks, true);
+          expect(layers).toHaveLength(2);
+          const firstClasses = layers[0].map((h) => h.class);
+          expect(firstClasses).toContain(B);
+          expect(firstClasses).toContain(C);
+          expect(layers[1].every((h) => h.class === A)).toBe(true);
+        });
+        test("multiple hooks per class are all in the same layer", () => {
+          const cb1 = () => {
+          };
+          const cb2 = () => {
+          };
+          const hooks = [
+            { cb: cb1, class: A, after: [] },
+            { cb: cb2, class: A, after: [] },
+            { cb: noop, class: B, after: [A] }
+          ];
+          const layers = resolveHookDAG(hooks);
+          expect(layers).toHaveLength(2);
+          expect(layers[0]).toHaveLength(2);
+          expect(layers[0].every((h) => h.class === A)).toBe(true);
+        });
+        test("anonymous hooks without deps run at deepest level", () => {
+          const hooks = [
+            { cb: noop, class: A, after: [] },
+            { cb: noop, class: B, after: [A] },
+            { cb: noop, after: [] }
+          ];
+          const layers = resolveHookDAG(hooks);
+          expect(layers).toHaveLength(2);
+          const lastLayer = layers[layers.length - 1];
+          expect(lastLayer.some((h) => h.class === void 0)).toBe(true);
+        });
+        test("anonymous hooks with deps run after their dependencies", () => {
+          const hooks = [
+            { cb: noop, class: A, after: [] },
+            { cb: noop, class: B, after: [A] },
+            { cb: noop, class: C, after: [B] },
+            { cb: noop, after: [A] }
+          ];
+          const layers = resolveHookDAG(hooks);
+          const anonLayer = layers.findIndex((l) => l.some((h) => h.class === void 0));
+          const aLayer = layers.findIndex((l) => l.some((h) => h.class === A));
+          expect(anonLayer).toBeGreaterThan(aLayer);
+        });
+        test("empty hooks returns empty layers", () => {
+          expect(resolveHookDAG([])).toEqual([]);
+        });
+      });
+      describe("runHooks", () => {
+        test("same-depth siblings observably overlap", async () => {
+          const log = [];
+          const hooks = [
+            {
+              cb: async () => {
+                log.push("B-start");
+                await new Promise((r) => setTimeout(r, 20));
+                log.push("B-end");
+              },
+              class: B,
+              after: []
+            },
+            {
+              cb: async () => {
+                log.push("C-start");
+                await new Promise((r) => setTimeout(r, 20));
+                log.push("C-end");
+              },
+              class: C,
+              after: []
+            }
+          ];
+          await runHooks(hooks);
+          expect(log[0]).toBe("B-start");
+          expect(log[1]).toBe("C-start");
+        });
+        test("different depths run sequentially", async () => {
+          const log = [];
+          const hooks = [
+            {
+              cb: async () => {
+                log.push("A");
+              },
+              class: A,
+              after: []
+            },
+            {
+              cb: async () => {
+                log.push("B");
+              },
+              class: B,
+              after: [A]
+            }
+          ];
+          await runHooks(hooks);
+          expect(log).toEqual(["A", "B"]);
+        });
+        test("close inversion runs hooks in reverse dependency order", async () => {
+          const log = [];
+          const hooks = [
+            { cb: async () => log.push("A"), class: A, after: [] },
+            { cb: async () => log.push("B"), class: B, after: [A] },
+            { cb: async () => log.push("C"), class: C, after: [B] }
+          ];
+          await runHooks(hooks, void 0, true);
+          expect(log).toEqual(["C", "B", "A"]);
+        });
+        test("errors are routed to onError handler", async () => {
+          const errors = [];
+          const hooks = [
+            {
+              cb: () => {
+                throw new Error("boom");
+              },
+              class: A,
+              after: []
+            }
+          ];
+          await runHooks(hooks, (e) => {
+            errors.push(e);
+          });
+          expect(errors).toHaveLength(1);
+          expect(errors[0].message).toBe("boom");
+        });
+        test("raw promise callbacks are awaited", async () => {
+          const log = [];
+          const hooks = [
+            {
+              cb: Promise.resolve().then(() => log.push("resolved")),
+              class: A,
+              after: []
+            }
+          ];
+          await runHooks(hooks);
+          expect(log).toContain("resolved");
+        });
+      });
+    }
+  }
+});
+
+// src/instance/settings.ts
+var import_valleyed, instanceSettingsPipe;
+var init_settings = __esm({
+  "src/instance/settings.ts"() {
+    "use strict";
+    import_valleyed = require("valleyed");
+    instanceSettingsPipe = () => import_valleyed.v.object({
+      app: import_valleyed.v.object({
+        name: import_valleyed.v.string()
+      }),
+      log: import_valleyed.v.defaults(
+        import_valleyed.v.object({
+          level: import_valleyed.v.defaults(import_valleyed.v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+        }),
+        {}
+      ),
+      utils: import_valleyed.v.defaults(
+        import_valleyed.v.object({
+          hashSaltRounds: import_valleyed.v.defaults(import_valleyed.v.number(), 10),
+          paginationDefaultLimit: import_valleyed.v.defaults(import_valleyed.v.number(), 100),
+          maxFileUploadSizeInMb: import_valleyed.v.defaults(import_valleyed.v.number(), 500)
+        }),
+        {}
+      )
+    });
+  }
+});
+
+// src/instance/index.ts
+var import_pino, import_ulid, import_valleyed2, Instance;
+var init_instance = __esm({
+  "src/instance/index.ts"() {
+    "use strict";
+    import_pino = __toESM(require("pino"), 1);
+    import_ulid = require("ulid");
+    import_valleyed2 = require("valleyed");
+    init_errors();
+    init_hooks();
+    init_settings();
+    Instance = class _Instance {
+      static #id;
+      static #instance;
+      static #hooks = {};
+      settings;
+      log;
+      constructor(settings) {
+        _Instance.#instance = this;
+        this.settings = Object.freeze(settings);
+        this.log = (0, import_pino.default)({
+          level: this.settings.log.level,
+          serializers: {
+            err: import_pino.default.stdSerializers.err,
+            error: import_pino.default.stdSerializers.err,
+            req: import_pino.default.stdSerializers.req,
+            res: import_pino.default.stdSerializers.res
+          },
+          mixin: () => ({
+            instanceId: _Instance.#id
+          })
+        });
+        _Instance.#registerOnExitHandler();
+      }
+      alias(id) {
+        if (_Instance.#id !== void 0) return _Instance.crash(new EquippedError("Instance already has an alias", {}));
+        _Instance.#id = id;
+      }
+      get id() {
+        if (_Instance.#id === void 0) return _Instance.crash(new EquippedError("Instance doesnt have an alias yet", {}));
+        return _Instance.#id;
+      }
+      getScopedName(name, key = ".") {
+        return [this.settings.app.name, name].join(key);
+      }
+      async start() {
+        try {
+          await runHooks(_Instance.#hooks["setup"] ?? []);
+          await runHooks(_Instance.#hooks["start"] ?? []);
+        } catch (error) {
+          _Instance.crash(new EquippedError(`Error starting instance`, {}, error));
+        }
+      }
+      static envs(envsPipe) {
+        const envValidity = import_valleyed2.v.validate(envsPipe, process.env);
+        if (!envValidity.valid) {
+          _Instance.crash(
+            new EquippedError(`Environment variables are not valid
+${envValidity.error.toString()}`, {
+              messages: envValidity.error.messages
+            })
+          );
+        }
+        return envValidity.value;
+      }
+      static create(settings) {
+        if (_Instance.#instance) return _Instance.crash(new EquippedError("Instance has been initialized already", {}));
+        const settingsValidity = import_valleyed2.v.validate(instanceSettingsPipe(), settings);
+        if (!settingsValidity.valid) {
+          _Instance.crash(
+            new EquippedError(`Settings are not valid
+${settingsValidity.error.toString()}`, {
+              messages: settingsValidity.error.messages
+            })
+          );
+        }
+        return new _Instance(settingsValidity.value);
+      }
+      static get() {
+        if (!_Instance.#instance)
+          return _Instance.crash(
+            new EquippedError("Has not been initialized. Make sure an instance has been created before you get an instance", {})
+          );
+        return _Instance.#instance;
+      }
+      static maybeGet() {
+        return _Instance.#instance;
+      }
+      static on(event, cb, options) {
+        _Instance.#hooks[event] ??= [];
+        const record = { cb, class: options?.class, after: options?.after ?? [] };
+        registerHook(_Instance.#hooks[event], record);
+      }
+      static #registerOnExitHandler() {
+        const signals = {
+          SIGHUP: 1,
+          SIGINT: 2,
+          SIGTERM: 15
+        };
+        Object.entries(signals).forEach(([signal, code]) => {
+          process.on(signal, async () => {
+            await runHooks(_Instance.#hooks["close"] ?? [], () => {
+            }, true);
+            process.exit(128 + code);
+          });
+        });
+      }
+      static resolveBeforeCrash(cb) {
+        const value = cb();
+        _Instance.on("close", async () => await value);
+        return value;
+      }
+      static crash(error) {
+        console.error(error);
+        process.exit(1);
+      }
+      static createId(opts) {
+        return `${opts?.prefix ?? ""}${(0, import_ulid.ulid)(opts?.time?.getTime())}`;
+      }
+    };
+  }
+});
+
+// src/utilities/authProviders.ts
+var import_axios, import_jsonwebtoken, import_jwks_rsa;
+var init_authProviders = __esm({
+  "src/utilities/authProviders.ts"() {
+    "use strict";
+    import_axios = __toESM(require("axios"), 1);
+    import_jsonwebtoken = __toESM(require("jsonwebtoken"), 1);
+    import_jwks_rsa = __toESM(require("jwks-rsa"), 1);
+  }
+});
+
+// src/utilities/configurable.ts
+function configurable(pipeFn, base) {
+  const pipe = pipeFn();
+  import_valleyed3.v.compile(pipe);
+  class Configurable extends base {
+    constructor(config, ...baseArgs) {
+      super(...baseArgs);
+      this.config = config;
+    }
+    static create(input, ...args) {
+      const r = import_valleyed3.v.validate(pipe, input);
+      if (!r.valid) throw r.error;
+      return new this(r.value, ...args);
+    }
+  }
+  return Configurable;
+}
+var import_valleyed3;
+var init_configurable = __esm({
+  "src/utilities/configurable.ts"() {
+    "use strict";
+    import_valleyed3 = require("valleyed");
+    if (void 0) {
+      const { describe, test, expect, expectTypeOf } = void 0;
+      const { v: v6 } = null;
+      const testPipe = () => v6.object({
+        host: v6.string(),
+        port: v6.number()
+      });
+      class TestBase {
+        baseValue;
+        constructor() {
+          this.baseValue = "base";
+        }
+      }
+      class TestBaseWithArgs {
+        label;
+        constructor(label) {
+          this.label = label;
+        }
+      }
+      describe("configurable", () => {
+        test("validation runs in static create before constructor body executes", () => {
+          let constructorRan = false;
+          const Wrapped = configurable(testPipe, TestBase);
+          class MyClass extends Wrapped {
+            constructor(config) {
+              super(config);
+              constructorRan = true;
+            }
+          }
+          expect(() => MyClass.create({ host: 123, port: "bad" })).toThrow();
+          expect(constructorRan).toBe(false);
+          MyClass.create({ host: "localhost", port: 3e3 });
+          expect(constructorRan).toBe(true);
+        });
+        test("constructor receives validated value", () => {
+          const Wrapped = configurable(testPipe, TestBase);
+          let receivedConfig;
+          class MyClass extends Wrapped {
+            constructor(config) {
+              super(config);
+              receivedConfig = this.config;
+            }
+          }
+          MyClass.create({ host: "localhost", port: 3e3 });
+          expect(receivedConfig).toEqual({ host: "localhost", port: 3e3 });
+        });
+        test("external new is a compile error", () => {
+          const Wrapped = configurable(testPipe, TestBase);
+          class MyClass extends Wrapped {
+            constructor(config) {
+              super(config);
+            }
+          }
+          void (() => new MyClass({ host: "localhost", port: 3e3 }));
+        });
+        test("static Config resolves to PipeOutput<P> at the type level", () => {
+          const Wrapped = configurable(testPipe, TestBase);
+          class MyClass extends Wrapped {
+            constructor(config) {
+              super(config);
+            }
+          }
+          expectTypeOf().toEqualTypeOf();
+          expect(MyClass.create).toBeTypeOf("function");
+        });
+        test("ConstructorParameters<This>-based extras inference works for non-zero-arg leaf signatures", () => {
+          const Wrapped = configurable(testPipe, TestBase);
+          class MyClass extends Wrapped {
+            extra;
+            constructor(config, extra) {
+              super(config);
+              this.extra = extra;
+            }
+          }
+          const instance = MyClass.create({ host: "localhost", port: 3e3 }, 42);
+          expect(instance.extra).toBe(42);
+          expectTypeOf(instance).toHaveProperty("extra");
+          expectTypeOf(instance.extra).toEqualTypeOf();
+          void (() => MyClass.create({ host: "localhost", port: 3e3 }, "not-a-number"));
+        });
+        test("base-args forwarding works for non-zero-arg bases", () => {
+          const Wrapped = configurable(testPipe, TestBaseWithArgs);
+          class MyClass extends Wrapped {
+            constructor(config, label) {
+              super(config, label);
+            }
+          }
+          const instance = MyClass.create({ host: "localhost", port: 3e3 }, "test-label");
+          expect(instance.label).toBe("test-label");
+        });
+        test("config is accessible as protected readonly on instances", () => {
+          const Wrapped = configurable(testPipe, TestBase);
+          class MyClass extends Wrapped {
+            constructor(config) {
+              super(config);
+            }
+            getHost() {
+              return this.config.host;
+            }
+          }
+          const instance = MyClass.create({ host: "localhost", port: 3e3 });
+          expect(instance.getHost()).toBe("localhost");
+        });
+        test("accepts an abstract base class", () => {
+          class AbstractBase {
+          }
+          const Wrapped = configurable(testPipe, AbstractBase);
+          class Concrete extends Wrapped {
+            constructor(config) {
+              super(config);
+            }
+            greet() {
+              return `hello from ${this.config.host}`;
+            }
+          }
+          const instance = Concrete.create({ host: "localhost", port: 3e3 });
+          expect(instance.greet()).toBe("hello from localhost");
+          expectTypeOf(instance).toHaveProperty("config");
+        });
+      });
+    }
+  }
+});
+
+// src/utilities/hash.ts
+var bcrypt;
+var init_hash = __esm({
+  "src/utilities/hash.ts"() {
+    "use strict";
+    bcrypt = __toESM(require("bcryptjs"), 1);
+  }
+});
+
+// src/utilities/json.ts
+var init_json = __esm({
+  "src/utilities/json.ts"() {
+    "use strict";
+  }
+});
+
+// src/utilities/media.ts
+var import_music_metadata;
+var init_media = __esm({
+  "src/utilities/media.ts"() {
+    "use strict";
+    import_music_metadata = require("music-metadata");
+  }
+});
+
+// src/utilities/random.ts
+var init_random = __esm({
+  "src/utilities/random.ts"() {
+    "use strict";
+  }
+});
+
+// src/utilities/retry.ts
+var init_retry = __esm({
+  "src/utilities/retry.ts"() {
+    "use strict";
+  }
+});
+
+// src/utilities/index.ts
+var init_utilities = __esm({
+  "src/utilities/index.ts"() {
+    "use strict";
+    init_authProviders();
+    init_configurable();
+    init_hash();
+    init_json();
+    init_media();
+    init_random();
+    init_retry();
+  }
+});
+
+// src/errors/types/badRequestError.ts
+var init_badRequestError = __esm({
+  "src/errors/types/badRequestError.ts"() {
+    "use strict";
+  }
+});
+
+// src/errors/types/notAuthenticatedError.ts
+var init_notAuthenticatedError = __esm({
+  "src/errors/types/notAuthenticatedError.ts"() {
+    "use strict";
+  }
+});
+
+// src/errors/types/notAuthorizedError.ts
+var init_notAuthorizedError = __esm({
+  "src/errors/types/notAuthorizedError.ts"() {
+    "use strict";
+  }
+});
+
+// src/errors/types/notFoundError.ts
+var init_notFoundError = __esm({
+  "src/errors/types/notFoundError.ts"() {
+    "use strict";
+  }
+});
+
+// src/errors/types/tokenExpired.ts
+var init_tokenExpired = __esm({
+  "src/errors/types/tokenExpired.ts"() {
+    "use strict";
+  }
+});
+
+// src/errors/types/validationError.ts
+var init_validationError = __esm({
+  "src/errors/types/validationError.ts"() {
+    "use strict";
+  }
+});
+
+// src/errors/index.ts
+var init_errors = __esm({
+  "src/errors/index.ts"() {
+    "use strict";
+    init_equippedError();
+    init_requestError();
+    init_badRequestError();
+    init_notAuthenticatedError();
+    init_notAuthorizedError();
+    init_notFoundError();
+    init_tokenExpired();
+    init_validationError();
+  }
+});
+
+// src/orm/errors/introspection.ts
+var introspection_exports = {};
+__export(introspection_exports, {
+  OrmIntrospectionError: () => OrmIntrospectionError
+});
+var OrmIntrospectionError;
+var init_introspection = __esm({
+  "src/orm/errors/introspection.ts"() {
+    "use strict";
+    init_errors();
+    OrmIntrospectionError = class extends EquippedError {
+      adapter;
+      table;
+      constructor(opts) {
+        super(`Introspection failed for table '${opts.table}' on adapter '${opts.adapter}'`, { adapter: opts.adapter, table: opts.table }, opts.cause);
+        this.adapter = opts.adapter;
+        this.table = opts.table;
+      }
+    };
+    if (void 0) {
+      const { describe, test, expect } = void 0;
+      const { EquippedError: EquippedError2 } = null;
+      describe("OrmIntrospectionError", () => {
+        test("stores adapter, table, and cause on the instance", () => {
+          const cause = new Error("unknown column type");
+          const err = new OrmIntrospectionError({ adapter: "postgres", table: "users", cause });
+          expect(err.adapter).toBe("postgres");
+          expect(err.table).toBe("users");
+          expect(err.cause).toBe(cause);
+        });
+        test("message includes adapter and table", () => {
+          const err = new OrmIntrospectionError({ adapter: "pg", table: "posts", cause: "bad type" });
+          expect(err.message).toBe("Introspection failed for table 'posts' on adapter 'pg'");
+        });
+        test("instanceof EquippedError is true", () => {
+          const err = new OrmIntrospectionError({ adapter: "x", table: "y", cause: null });
+          expect(err).toBeInstanceOf(OrmIntrospectionError);
+          expect(err).toBeInstanceOf(EquippedError2);
+        });
+        test("context carries adapter and table", () => {
+          const err = new OrmIntrospectionError({ adapter: "mem", table: "items", cause: "fail" });
+          expect(err.context.adapter).toBe("mem");
+          expect(err.context.table).toBe("items");
+        });
+        test("discriminates from sibling error classes", async () => {
+          const { OrmMigrationError } = await null;
+          const { OrmValidationError: OrmValidationError2 } = await null;
+          const err = new OrmIntrospectionError({ adapter: "x", table: "y", cause: null });
+          expect(err).not.toBeInstanceOf(OrmMigrationError);
+          expect(err).not.toBeInstanceOf(OrmValidationError2);
+        });
+      });
+    }
+  }
+});
+
+// src/orm/adapters/postgresql/index.ts
+var postgresql_exports = {};
+__export(postgresql_exports, {
+  PostgresAdapter: () => PostgresAdapter
+});
+module.exports = __toCommonJS(postgresql_exports);
+var import_node_async_hooks = require("async_hooks");
+var import_pg = require("pg");
+var import_pg_cursor = __toESM(require("pg-cursor"), 1);
+var import_valleyed5 = require("valleyed");
+
+// src/orm/filter.ts
+init_errors();
+
+// src/orm/fields.ts
+var import_valleyed4 = require("valleyed");
+var Field = class {
+  name;
+  path;
+  constructor(name, path) {
+    this.name = name;
+    this.path = path ?? [name];
+  }
+};
+function toFieldName(field) {
+  if (field instanceof Field) return field.path.join(".");
+  return field;
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  describe("Fields", () => {
+    describe("Field", () => {
+      test("stores name and defaults path to [name]", () => {
+        const f = new Field("email");
+        expect(f.name).toBe("email");
+        expect(f.path).toEqual(["email"]);
+      });
+      test("stores provided custom path", () => {
+        const f = new Field("profile", ["profile", "displayName"]);
+        expect(f.name).toBe("profile");
+        expect(f.path).toEqual(["profile", "displayName"]);
+      });
+    });
+    describe("toFieldName()", () => {
+      test("returns string input unchanged", () => {
+        expect(toFieldName("createdAt")).toBe("createdAt");
+      });
+      test("converts Field path into dot notation", () => {
+        const f = new Field("profile", ["profile", "displayName"]);
+        expect(toFieldName(f)).toBe("profile.displayName");
+      });
+    });
+    describe("SchemaField", () => {
+      test("extends Field and stores pipe", () => {
+        const mockPipe = v4.string();
+        const f = new SchemaField("email", mockPipe);
+        expect(f).toBeInstanceOf(Field);
+        expect(f.name).toBe("email");
+        expect(f.path).toEqual(["email"]);
+        expect(f.pipe).toBe(mockPipe);
+      });
+      test("stores lifecycle hooks when provided", () => {
+        const mockPipe = v4.number();
+        const f = new SchemaField("updatedAt", mockPipe, {
+          onCreate: () => 1e3,
+          onUpdate: () => 2e3
+        });
+        expect(f.onCreate?.()).toBe(1e3);
+        expect(f.onUpdate?.()).toBe(2e3);
+      });
+      test("keeps lifecycle hooks undefined when omitted", () => {
+        const mockPipe = v4.string();
+        const f = new SchemaField("name", mockPipe);
+        expect(f.onCreate).toBeUndefined();
+        expect(f.onUpdate).toBeUndefined();
+      });
+    });
+  });
+}
+
+// src/orm/filter.ts
+var Filter = class {
+  constructor(field, op, value) {
+    this.op = op;
+    this.value = value;
+    this.field = toFieldName(field);
+  }
+  field;
+};
+var FilterGroup = class _FilterGroup {
+  constructor(op = "and", children) {
+    this.op = op;
+    this.children = children ?? [];
+  }
+  children;
+  #withChild(child) {
+    return new _FilterGroup(this.op, [...this.children, child]);
+  }
+  eq(field, value) {
+    return this.#withChild(new Filter(field, "eq", value));
+  }
+  ne(field, value) {
+    return this.#withChild(new Filter(field, "ne", value));
+  }
+  gt(field, value) {
+    return this.#withChild(new Filter(field, "gt", value));
+  }
+  gte(field, value) {
+    return this.#withChild(new Filter(field, "gte", value));
+  }
+  lt(field, value) {
+    return this.#withChild(new Filter(field, "lt", value));
+  }
+  lte(field, value) {
+    return this.#withChild(new Filter(field, "lte", value));
+  }
+  in(field, value) {
+    return this.#withChild(new Filter(field, "in", value));
+  }
+  notIn(field, value) {
+    return this.#withChild(new Filter(field, "notIn", value));
+  }
+  like(field, value) {
+    return this.#withChild(new Filter(field, "like", value));
+  }
+  exists(field) {
+    return this.#withChild(new Filter(field, "exists", true));
+  }
+  notExists(field) {
+    return this.#withChild(new Filter(field, "notExists", true));
+  }
+  contains(field, value) {
+    return this.#withChild(new Filter(field, "contains", value));
+  }
+  notContains(field, value) {
+    return this.#withChild(new Filter(field, "notContains", value));
+  }
+  and(facFns) {
+    if (facFns.length === 0) throw new EquippedError("and() requires at least one filter factory", { op: "and" });
+    const group = new _FilterGroup("and", facFns.map((fn) => fn(_FilterGroup.create())));
+    return this.#withChild(group);
+  }
+  or(facFns) {
+    if (facFns.length === 0) throw new EquippedError("or() requires at least one filter factory", { op: "or" });
+    const group = new _FilterGroup("or", facFns.map((fn) => fn(_FilterGroup.create())));
+    return this.#withChild(group);
+  }
+  clone() {
+    return new _FilterGroup(
+      this.op,
+      this.children.map((c) => {
+        if (c instanceof Filter) return new Filter(c.field, c.op, structuredClone(c.value));
+        return c.clone();
+      })
+    );
+  }
+  static create() {
+    return new _FilterGroup();
+  }
+};
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { v: v6 } = null;
+  const { Schema } = null;
+  const UserSchema = Schema.from("users").pk("id", v6.string(), () => "u1").field("email", v6.string()).field("age", v6.number()).field("name", v6.string()).field("tags", v6.array(v6.string())).build();
+  describe("FilterGroup", () => {
+    describe("filter-op methods", () => {
+      test("eq adds a filter clause with op eq", () => {
+        const g = FilterGroup.create().eq(UserSchema.fields.age, 25);
+        expect(g.children).toHaveLength(1);
+        const f = g.children[0];
+        expect(f.field).toBe("age");
+        expect(f.op).toBe("eq");
+        expect(f.value).toBe(25);
+      });
+      test("ne adds a filter clause with op ne", () => {
+        const g = FilterGroup.create().ne("name", "Bob");
+        const f = g.children[0];
+        expect(f.op).toBe("ne");
+        expect(f.value).toBe("Bob");
+      });
+      test("gt/gte/lt/lte produce correct ops", () => {
+        const g = FilterGroup.create().gt(UserSchema.fields.age, 10).gte(UserSchema.fields.age, 20).lt(UserSchema.fields.age, 30).lte(UserSchema.fields.age, 40);
+        expect(g.children.map((c) => c.op)).toEqual(["gt", "gte", "lt", "lte"]);
+      });
+      test("in adds a filter clause with array value", () => {
+        const g = FilterGroup.create().in(UserSchema.fields.age, [1, 2, 3]);
+        const f = g.children[0];
+        expect(f.op).toBe("in");
+        expect(f.value).toEqual([1, 2, 3]);
+      });
+      test("notIn adds a filter clause with op notIn", () => {
+        const g = FilterGroup.create().notIn(UserSchema.fields.age, [4, 5]);
+        const f = g.children[0];
+        expect(f.op).toBe("notIn");
+        expect(f.value).toEqual([4, 5]);
+      });
+      test("like adds a filter clause with op like", () => {
+        const g = FilterGroup.create().like(UserSchema.fields.email, "alice");
+        const f = g.children[0];
+        expect(f.op).toBe("like");
+        expect(f.value).toBe("alice");
+      });
+      test("exists adds a filter clause with op exists", () => {
+        const g = FilterGroup.create().exists(UserSchema.fields.name);
+        const f = g.children[0];
+        expect(f.op).toBe("exists");
+      });
+      test("notExists is its own op, not a boolean form of exists", () => {
+        const g = FilterGroup.create().notExists(UserSchema.fields.name);
+        const f = g.children[0];
+        expect(f.op).toBe("notExists");
+        expect(f.op).not.toBe("exists");
+      });
+      test("contains/notContains produce correct ops", () => {
+        const g = FilterGroup.create().contains("tags", ["a"]).notContains("tags", ["b"]);
+        expect(g.children[0].op).toBe("contains");
+        expect(g.children[1].op).toBe("notContains");
+      });
+      test("all 13 filter ops produce matching Filter.op values (name-parity)", () => {
+        const g = FilterGroup.create().eq("f", 1).ne("f", 1).gt("f", 1).gte("f", 1).lt("f", 1).lte("f", 1).in("f", [1]).notIn("f", [1]).like("f", "x").exists("f").notExists("f").contains("f", [1]).notContains("f", [1]);
+        const ops = g.children.map((c) => c.op);
+        expect(ops).toEqual([
+          "eq",
+          "ne",
+          "gt",
+          "gte",
+          "lt",
+          "lte",
+          "in",
+          "notIn",
+          "like",
+          "exists",
+          "notExists",
+          "contains",
+          "notContains"
+        ]);
+      });
+    });
+    describe("raw-string field overload", () => {
+      test("accepts raw string field name", () => {
+        const g = FilterGroup.create().eq("age", 18);
+        const f = g.children[0];
+        expect(f.field).toBe("age");
+      });
+      test("accepts typed Field ref and extracts field name", () => {
+        const g = FilterGroup.create().eq(UserSchema.fields.age, 18);
+        const f = g.children[0];
+        expect(f.field).toBe("age");
+      });
+    });
+    describe("structural combinators", () => {
+      test("and() creates a nested and-group", () => {
+        const g = FilterGroup.create().and([
+          (q) => q.eq("age", 10),
+          (q) => q.eq("name", "Alice")
+        ]);
+        expect(g.children).toHaveLength(1);
+        const nested = g.children[0];
+        expect(nested.op).toBe("and");
+        expect(nested.children).toHaveLength(2);
+      });
+      test("or() creates a nested or-group", () => {
+        const g = FilterGroup.create().or([
+          (q) => q.eq("name", "Alice"),
+          (q) => q.eq("name", "Bob")
+        ]);
+        const nested = g.children[0];
+        expect(nested.op).toBe("or");
+      });
+    });
+    describe("empty-combinator rejection", () => {
+      test("and([]) throws at builder time", () => {
+        expect(() => FilterGroup.create().and([])).toThrow();
+      });
+      test("or([]) throws at builder time", () => {
+        expect(() => FilterGroup.create().or([])).toThrow();
+      });
+      test("thrown error has stack pointing at offending call", () => {
+        try {
+          FilterGroup.create().and([]);
+          expect.unreachable();
+        } catch (e) {
+          expect(e.stack).toContain("filter.ts");
+        }
+      });
+    });
+    describe("clone()", () => {
+      test("deep-clones the tree", () => {
+        const original = FilterGroup.create().eq("name", "Alice").and([(q) => q.gt("age", 20)]);
+        const cloned = original.clone();
+        expect(cloned.children).toHaveLength(2);
+        expect(cloned).not.toBe(original);
+        expect(cloned.children[0]).not.toBe(original.children[0]);
+      });
+      test("structuredClone of values \u2014 mutations on clone do not leak", () => {
+        const arr = [1, 2, 3];
+        const original = FilterGroup.create().in("ids", arr);
+        const cloned = original.clone();
+        const clonedValue = cloned.children[0].value;
+        clonedValue.push(4);
+        expect(original.children[0].value).toEqual([1, 2, 3]);
+        expect(clonedValue).toEqual([1, 2, 3, 4]);
+      });
+    });
+  });
+  describe("clone-on-step: fan-out independence", () => {
+    test(".eq() returns a new FilterGroup, not the same instance", () => {
+      const base = FilterGroup.create();
+      const a = base.eq("name", "Alice");
+      expect(a).not.toBe(base);
+    });
+    test("fan-out from shared base does not pollute either branch", () => {
+      const base = FilterGroup.create().eq("name", "Alice");
+      const branchA = base.gt("age", 20);
+      const branchB = base.lt("age", 40);
+      expect(branchA.children).toHaveLength(2);
+      expect(branchB.children).toHaveLength(2);
+      expect(base.children).toHaveLength(1);
+      expect(branchA.children[1].op).toBe("gt");
+      expect(branchB.children[1].op).toBe("lt");
+    });
+    test(".and() returns a new FilterGroup", () => {
+      const base = FilterGroup.create().eq("name", "Alice");
+      const withAnd = base.and([(q) => q.gt("age", 20)]);
+      expect(withAnd).not.toBe(base);
+      expect(base.children).toHaveLength(1);
+      expect(withAnd.children).toHaveLength(2);
+    });
+    test(".or() returns a new FilterGroup", () => {
+      const base = FilterGroup.create().eq("name", "Alice");
+      const withOr = base.or([(q) => q.gt("age", 20)]);
+      expect(withOr).not.toBe(base);
+      expect(base.children).toHaveLength(1);
+      expect(withOr.children).toHaveLength(2);
+    });
+  });
+  describe("assertNormalisedFilter", () => {
+    test("passes for valid filter referencing known fields", () => {
+      const g = FilterGroup.create().eq(UserSchema.fields.age, 25);
+      expect(() => assertNormalisedFilter(UserSchema, g)).not.toThrow();
+    });
+    test("passes for raw string field that exists on schema", () => {
+      const g = FilterGroup.create().eq("email", "test@test.com");
+      expect(() => assertNormalisedFilter(UserSchema, g)).not.toThrow();
+    });
+    test("rejects unknown field name with OrmValidationError", () => {
+      const g = FilterGroup.create().eq("unknownField", 42);
+      expect(() => assertNormalisedFilter(UserSchema, g)).toThrow(OrmValidationError);
+    });
+    test("rejected error has kind validation", () => {
+      const g = FilterGroup.create().eq("badField", 42);
+      try {
+        assertNormalisedFilter(UserSchema, g);
+        expect.unreachable();
+      } catch (e) {
+        expect(e).toBeInstanceOf(OrmValidationError);
+        expect(e.kind).toBe("validation");
+        expect(e.failures).toHaveLength(1);
+        expect(e.failures[0].field).toBe("badField");
+      }
+    });
+    test("preserves logical field names verbatim for Field refs", () => {
+      const g = FilterGroup.create().eq(UserSchema.fields.email, "a@b.com");
+      const f = g.children[0];
+      expect(f.field).toBe("email");
+      assertNormalisedFilter(UserSchema, g);
+    });
+    test("preserves logical field names verbatim for raw-string overloads", () => {
+      const g = FilterGroup.create().eq("age", 18);
+      const f = g.children[0];
+      expect(f.field).toBe("age");
+      assertNormalisedFilter(UserSchema, g);
+    });
+    test("walks nested groups to detect unknown fields", () => {
+      const g = FilterGroup.create().and([
+        (q) => q.eq("name", "Alice"),
+        (q) => q.or([(inner) => inner.eq("nonexistent", "val")])
+      ]);
+      expect(() => assertNormalisedFilter(UserSchema, g)).toThrow(OrmValidationError);
+    });
+  });
+  describe("assertNormalisedAggregate", () => {
+    const adapter = { aggregateOps: ["count"] };
+    test("passes for valid count aggregate", () => {
+      const spec = { aggregates: [{ fn: "count", alias: "total" }], groupBy: [] };
+      expect(() => assertNormalisedAggregate(UserSchema, adapter, spec)).not.toThrow();
+    });
+    test("rejects empty aggregator list", () => {
+      const spec = { aggregates: [], groupBy: [] };
+      expect(() => assertNormalisedAggregate(UserSchema, adapter, spec)).toThrow(OrmValidationError);
+      try {
+        assertNormalisedAggregate(UserSchema, adapter, spec);
+        expect.unreachable();
+      } catch (e) {
+        expect(e.kind).toBe("aggregate");
+      }
+    });
+    test("rejects undeclared aggregate op", () => {
+      const spec = { aggregates: [{ fn: "sum", alias: "total", field: "age" }], groupBy: [] };
+      expect(() => assertNormalisedAggregate(UserSchema, adapter, spec)).toThrow(OrmValidationError);
+      try {
+        assertNormalisedAggregate(UserSchema, adapter, spec);
+        expect.unreachable();
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("aggregate");
+        expect(err.failures[0].alias).toBe("total");
+        expect(err.failures[0].cause).toContain("Undeclared");
+      }
+    });
+    test("rejects duplicate aliases", () => {
+      const spec = {
+        aggregates: [
+          { fn: "count", alias: "total" },
+          { fn: "count", alias: "total" }
+        ],
+        groupBy: []
+      };
+      expect(() => assertNormalisedAggregate(UserSchema, adapter, spec)).toThrow(OrmValidationError);
+      try {
+        assertNormalisedAggregate(UserSchema, adapter, spec);
+        expect.unreachable();
+      } catch (e) {
+        const err = e;
+        expect(err.failures.some((f) => f.alias === "total")).toBe(true);
+      }
+    });
+    test("validates where filter against schema", () => {
+      const spec = {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: [],
+        where: FilterGroup.create().eq("unknownField", 42)
+      };
+      expect(() => assertNormalisedAggregate(UserSchema, adapter, spec)).toThrow(OrmValidationError);
+    });
+    test("collects multiple failures", () => {
+      const spec = {
+        aggregates: [
+          { fn: "sum", alias: "x", field: "age" },
+          { fn: "avg", alias: "x", field: "age" }
+        ],
+        groupBy: []
+      };
+      try {
+        assertNormalisedAggregate(UserSchema, adapter, spec);
+        expect.unreachable();
+      } catch (e) {
+        const err = e;
+        expect(err.failures.length).toBeGreaterThanOrEqual(2);
+      }
+    });
+    test("rejects unknown groupBy field", () => {
+      const allOps = { aggregateOps: ["count", "sum"] };
+      const spec = {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: ["nonexistent"]
+      };
+      try {
+        assertNormalisedAggregate(UserSchema, allOps, spec);
+        expect.unreachable();
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("aggregate");
+        expect(err.failures[0].cause).toContain("groupBy");
+        expect(err.failures[0].field).toBe("nonexistent");
+      }
+    });
+    test("rejects alias colliding with groupBy field name", () => {
+      const allOps = { aggregateOps: ["count"] };
+      const spec = {
+        aggregates: [{ fn: "count", alias: "name" }],
+        groupBy: ["name"]
+      };
+      try {
+        assertNormalisedAggregate(UserSchema, allOps, spec);
+        expect.unreachable();
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("aggregate");
+        expect(err.failures.some((f) => String(f.cause).includes("collides"))).toBe(true);
+      }
+    });
+    test("rejects unknown having field", () => {
+      const allOps = { aggregateOps: ["count"] };
+      const spec = {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: ["name"],
+        having: FilterGroup.create().gt("nonexistent", 0)
+      };
+      try {
+        assertNormalisedAggregate(UserSchema, allOps, spec);
+        expect.unreachable();
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("aggregate");
+        expect(err.failures[0].cause).toContain("having");
+      }
+    });
+    test("having accepts alias and groupBy field names", () => {
+      const allOps = { aggregateOps: ["count"] };
+      const spec = {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: ["name"],
+        having: FilterGroup.create().gt("total", 0).eq("name", "Alice")
+      };
+      expect(() => assertNormalisedAggregate(UserSchema, allOps, spec)).not.toThrow();
+    });
+    test("passes valid groupBy with known schema fields", () => {
+      const allOps = { aggregateOps: ["count"] };
+      const spec = {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: ["name", "age"]
+      };
+      expect(() => assertNormalisedAggregate(UserSchema, allOps, spec)).not.toThrow();
+    });
+  });
+}
+
+// src/orm/errors/validation.ts
+init_errors();
+var OrmValidationError = class extends EquippedError {
+  constructor(kind, schema, operation, failures) {
+    super(`ORM validation error (${kind}) on ${schema}.${operation}`, {
+      kind,
+      schema,
+      operation,
+      failures
+    });
+    this.kind = kind;
+    this.schema = schema;
+    this.operation = operation;
+    this.failures = failures;
+  }
+};
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { EquippedError: EquippedError2 } = null;
+  describe("OrmValidationError", () => {
+    test("constructs with aggregate kind", () => {
+      const err = new OrmValidationError("aggregate", "orders", "aggregate", []);
+      expect(err.kind).toBe("aggregate");
+      expect(err.operation).toBe("aggregate");
+      expect(err.message).toBe("ORM validation error (aggregate) on orders.aggregate");
+      expect(err).toBeInstanceOf(OrmValidationError);
+      expect(err).toBeInstanceOf(EquippedError2);
+    });
+    test("failure carries alias through to context", () => {
+      const failures = [
+        { alias: "total_price", cause: "alias collision" }
+      ];
+      const err = new OrmValidationError("aggregate", "orders", "aggregate", failures);
+      expect(err.failures[0].alias).toBe("total_price");
+      expect(err.context.failures[0].alias).toBe("total_price");
+    });
+    test("failure without alias still works", () => {
+      const failures = [
+        { field: "amount", cause: "invalid field" }
+      ];
+      const err = new OrmValidationError("validation", "orders", "createOne", failures);
+      expect(err.failures[0].alias).toBeUndefined();
+      expect(err.failures[0].field).toBe("amount");
+    });
+    test.each([
+      "validation",
+      "conflicting-ops",
+      "empty-group",
+      "undeclared-op",
+      "upsert-filter-incompatible",
+      "query-shape",
+      "changes"
+    ])("kind %s still works", (kind) => {
+      const err = new OrmValidationError(kind, "users", "createOne", []);
+      expect(err.kind).toBe(kind);
+    });
+  });
+}
+
+// src/orm/updates.ts
+var SetOp = class {
+  constructor(values) {
+    this.values = values;
+  }
+  kind = "set";
+};
+var IncOp = class {
+  constructor(field, value) {
+    this.field = field;
+    this.value = value;
+  }
+  kind = "inc";
+};
+var MulOp = class {
+  constructor(field, value) {
+    this.field = field;
+    this.value = value;
+  }
+  kind = "mul";
+};
+var MinOp = class {
+  constructor(field, value) {
+    this.field = field;
+    this.value = value;
+  }
+  kind = "min";
+};
+var MaxOp = class {
+  constructor(field, value) {
+    this.field = field;
+    this.value = value;
+  }
+  kind = "max";
+};
+var UnsetOp = class {
+  constructor(field) {
+    this.field = field;
+  }
+  kind = "unset";
+};
+var PushOp = class {
+  constructor(field, value) {
+    this.field = field;
+    this.value = value;
+  }
+  kind = "push";
+};
+var PullOp = class {
+  constructor(field, value) {
+    this.field = field;
+    this.value = value;
+  }
+  kind = "pull";
+};
+var PatchOp = class {
+  constructor(field, value) {
+    this.field = field;
+    this.value = value;
+  }
+  kind = "patch";
+};
+function flattenOps(ops) {
+  const data = {};
+  for (const op of ops) {
+    if (op instanceof SetOp) Object.assign(data, op.values);
+    else data[op.field] = op;
+  }
+  return data;
+}
+if (void 0) {
+  const { describe, test, expect, expectTypeOf } = void 0;
+  const { v: v6 } = null;
+  const { Schema } = null;
+  const TestSchema = Schema.from("test").pk("id", v6.string(), () => "x").field("name", v6.string()).field("age", v6.number()).field("score", v6.optional(v6.number())).field("tags", v6.array(v6.string())).field("meta", v6.object({ a: v6.number() })).field("createdAt", v6.number(), { onCreate: () => 1e3 }).field("updatedAt", v6.number(), { onCreate: () => 1e3, onUpdate: () => 2e3 }).build();
+  describe("op classes", () => {
+    test('SetOp has kind "set" and stores values', () => {
+      const op = new SetOp({ name: "Alice" });
+      expect(op.kind).toBe("set");
+      expect(op.values).toEqual({ name: "Alice" });
+    });
+    test('IncOp has kind "inc" and stores field + value', () => {
+      const op = new IncOp("age", 5);
+      expect(op.kind).toBe("inc");
+      expect(op.field).toBe("age");
+      expect(op.value).toBe(5);
+    });
+    test('MulOp has kind "mul" and stores field + value', () => {
+      const op = new MulOp("score", 3);
+      expect(op.kind).toBe("mul");
+      expect(op.field).toBe("score");
+      expect(op.value).toBe(3);
+    });
+    test('MinOp has kind "min"', () => {
+      expect(new MinOp("age", 10).kind).toBe("min");
+    });
+    test('MaxOp has kind "max"', () => {
+      expect(new MaxOp("age", 99).kind).toBe("max");
+    });
+    test('UnsetOp has kind "unset"', () => {
+      expect(new UnsetOp("score").kind).toBe("unset");
+    });
+    test('PushOp has kind "push"', () => {
+      expect(new PushOp("tags", "x").kind).toBe("push");
+    });
+    test('PullOp has kind "pull"', () => {
+      expect(new PullOp("tags", "x").kind).toBe("pull");
+    });
+    test('PatchOp has kind "patch"', () => {
+      expect(new PatchOp("meta", { a: 9 }).kind).toBe("patch");
+    });
+  });
+  describe("isUpdateOp", () => {
+    test("returns true for every op class", () => {
+      expect(isUpdateOp(new SetOp({}))).toBe(true);
+      expect(isUpdateOp(new IncOp("f", 1))).toBe(true);
+      expect(isUpdateOp(new MulOp("f", 2))).toBe(true);
+      expect(isUpdateOp(new MinOp("f", 0))).toBe(true);
+      expect(isUpdateOp(new MaxOp("f", 10))).toBe(true);
+      expect(isUpdateOp(new UnsetOp("f"))).toBe(true);
+      expect(isUpdateOp(new PushOp("f", "v"))).toBe(true);
+      expect(isUpdateOp(new PullOp("f", "v"))).toBe(true);
+      expect(isUpdateOp(new PatchOp("f", {}))).toBe(true);
+    });
+    test("returns false for non-op values", () => {
+      expect(isUpdateOp("string")).toBe(false);
+      expect(isUpdateOp(42)).toBe(false);
+      expect(isUpdateOp(null)).toBe(false);
+      expect(isUpdateOp({})).toBe(false);
+    });
+  });
+  describe("op helper functions", () => {
+    test("set() creates SetOp with values", () => {
+      const op = set({ name: "Alice", age: 30 });
+      expect(op).toBeInstanceOf(SetOp);
+      expect(op.kind).toBe("set");
+      expect(op.values).toEqual({ name: "Alice", age: 30 });
+    });
+    test("inc() creates IncOp from field ref", () => {
+      const op = inc(TestSchema.fields.age, 5);
+      expect(op).toBeInstanceOf(IncOp);
+      expect(op.field).toBe("age");
+      expect(op.value).toBe(5);
+    });
+    test("mul() creates MulOp from field ref", () => {
+      const op = mul(TestSchema.fields.age, 3);
+      expect(op).toBeInstanceOf(MulOp);
+      expect(op.field).toBe("age");
+      expect(op.value).toBe(3);
+    });
+    test("min() creates MinOp from field ref", () => {
+      const op = min(TestSchema.fields.age, 10);
+      expect(op).toBeInstanceOf(MinOp);
+      expect(op.field).toBe("age");
+    });
+    test("max() creates MaxOp from field ref", () => {
+      const op = max(TestSchema.fields.age, 99);
+      expect(op).toBeInstanceOf(MaxOp);
+      expect(op.field).toBe("age");
+    });
+    test("unset() creates UnsetOp from field ref", () => {
+      const op = unset(TestSchema.fields.score);
+      expect(op).toBeInstanceOf(UnsetOp);
+      expect(op.field).toBe("score");
+    });
+    test("push() creates PushOp from field ref", () => {
+      const op = push(TestSchema.fields.tags, "new-tag");
+      expect(op).toBeInstanceOf(PushOp);
+      expect(op.field).toBe("tags");
+      expect(op.value).toBe("new-tag");
+    });
+    test("pull() creates PullOp from field ref", () => {
+      const op = pull(TestSchema.fields.tags, "old-tag");
+      expect(op).toBeInstanceOf(PullOp);
+      expect(op.field).toBe("tags");
+    });
+    test("patch() creates PatchOp from field ref", () => {
+      const op = patch(TestSchema.fields.meta, { a: 9 });
+      expect(op).toBeInstanceOf(PatchOp);
+      expect(op.field).toBe("meta");
+      expect(op.value).toEqual({ a: 9 });
+    });
+  });
+  describe("opTouchedFields", () => {
+    test("SetOp returns all keys from values", () => {
+      expect(opTouchedFields(new SetOp({ name: "A", age: 1 }))).toEqual(["name", "age"]);
+    });
+    test("IncOp returns the field", () => {
+      expect(opTouchedFields(new IncOp("age", 1))).toEqual(["age"]);
+    });
+    test("UnsetOp returns the field", () => {
+      expect(opTouchedFields(new UnsetOp("score"))).toEqual(["score"]);
+    });
+  });
+  describe("type-level: field-category helpers", () => {
+    test("NumericFieldOf only matches numeric fields (excludes optional numeric)", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("ComparableFieldOf matches numeric and string fields (excludes optional)", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("OptionalFieldOf only matches optional fields", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("ArrayFieldOf only matches array fields", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("ObjectFieldOf only matches object fields (not arrays)", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+  describe("type-level: inc on a string field is a TS error", () => {
+    test("inc rejects non-numeric fields", () => {
+      inc(TestSchema.fields.name, 1);
+    });
+  });
+  describe("type-level: push on a non-array field is a TS error", () => {
+    test("push rejects non-array fields", () => {
+      push(TestSchema.fields.name, "val");
+    });
+  });
+  describe("type-level: per-op gating via UpdateOp<S, A>", () => {
+    test("undeclared ops resolve to never", async () => {
+      const { OrmAdapter: OrmAdapter2 } = await null;
+      class LimitedAdapter extends OrmAdapter2 {
+        schemaConfigPipe = v6.object({});
+        supportedFieldTypes = ["string", "number"];
+        updateOps = ["set", "inc"];
+      }
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("adapter with no updateOps resolves all variants to never", async () => {
+      const { OrmAdapter: OrmAdapter2 } = await null;
+      class NoOpsAdapter extends OrmAdapter2 {
+        schemaConfigPipe = v6.object({});
+        supportedFieldTypes = ["string"];
+        updateOps = [];
+      }
+      expectTypeOf().toBeNever();
+    });
+    test("adapter with all updateOps includes all variants", async () => {
+      const { OrmAdapter: OrmAdapter2 } = await null;
+      class FullAdapter extends OrmAdapter2 {
+        schemaConfigPipe = v6.object({});
+        supportedFieldTypes = ["string", "number"];
+        updateOps = ["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"];
+      }
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+}
+
+// src/orm/adapters/postgresql/query.ts
+function mapField(field, primaryKey) {
+  if (field === "id" && primaryKey !== "id") return primaryKey;
+  return field;
+}
+function compileOps(f, field, nextParam) {
+  switch (f.op) {
+    case "eq":
+      return f.value === null ? `${field} IS NULL` : `${field} = ${nextParam(f.value)}`;
+    case "ne":
+      return f.value === null ? `${field} IS NOT NULL` : `${field} != ${nextParam(f.value)}`;
+    case "gt":
+      return `${field} > ${nextParam(f.value)}`;
+    case "gte":
+      return `${field} >= ${nextParam(f.value)}`;
+    case "lt":
+      return `${field} < ${nextParam(f.value)}`;
+    case "lte":
+      return `${field} <= ${nextParam(f.value)}`;
+    case "in":
+      return `${field} = ANY(${nextParam(f.value)})`;
+    case "notIn":
+      return `NOT (${field} = ANY(${nextParam(f.value)}))`;
+    case "like":
+      return `${field} ILIKE ${nextParam(`%${f.value}%`)}`;
+    case "exists":
+      return `${field} IS NOT NULL`;
+    case "notExists":
+      return `${field} IS NULL`;
+    case "contains":
+      return `${field} @> ${nextParam(JSON.stringify(f.value))}::jsonb`;
+    case "notContains":
+      return `NOT (${field} @> ${nextParam(JSON.stringify(f.value))}::jsonb)`;
+    default:
+      return `${field} = ${nextParam(f.value)}`;
+  }
+}
+function compileFilter(f, primaryKey, nextParam) {
+  return compileOps(f, `"${mapField(f.field, primaryKey)}"`, nextParam);
+}
+function compileChildren(group, compileLeaf) {
+  return group.children.map((c) => compileChild(c, compileLeaf)).filter((c) => c !== null);
+}
+function compileGroup(group, compileLeaf) {
+  const parts = compileChildren(group, compileLeaf);
+  if (parts.length === 0) return null;
+  if (parts.length === 1) return parts[0];
+  return `(${parts.join(group.op === "or" ? " OR " : " AND ")})`;
+}
+function compileChild(child, compileLeaf) {
+  if (child instanceof Filter) return compileLeaf(child);
+  if (child instanceof FilterGroup) return compileGroup(child, compileLeaf);
+  return null;
+}
+function compilePgFilter(group, primaryKey, startIndex = 1) {
+  const params = [];
+  let paramIndex = startIndex;
+  function nextParam(value) {
+    params.push(value);
+    return `$${paramIndex++}`;
+  }
+  const leaf = (f) => compileFilter(f, primaryKey, nextParam);
+  const whereParts = compileChildren(group, leaf);
+  const whereClause = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
+  return { whereClause, params, nextParamIndex: paramIndex };
+}
+function buildSetParts(data, startIndex) {
+  const params = [];
+  let paramIndex = startIndex;
+  const setParts = Object.entries(data).map(([key, value]) => {
+    const col = `"${key}"`;
+    if (value instanceof IncOp) {
+      params.push(value.value);
+      return `${col} = ${col} + $${paramIndex++}`;
+    }
+    if (value instanceof MulOp) {
+      params.push(value.value);
+      return `${col} = ${col} * $${paramIndex++}`;
+    }
+    if (value instanceof MinOp) {
+      params.push(value.value);
+      return `${col} = LEAST(${col}, $${paramIndex++})`;
+    }
+    if (value instanceof MaxOp) {
+      params.push(value.value);
+      return `${col} = GREATEST(${col}, $${paramIndex++})`;
+    }
+    if (value instanceof UnsetOp) {
+      return `${col} = NULL`;
+    }
+    if (value instanceof PushOp) {
+      params.push(JSON.stringify(value.value));
+      return `${col} = ${col} || jsonb_build_array($${paramIndex++}::jsonb)`;
+    }
+    if (value instanceof PullOp) {
+      params.push(JSON.stringify(value.value));
+      return `${col} = (SELECT COALESCE(jsonb_agg(e), '[]'::jsonb) FROM jsonb_array_elements(${col}) e WHERE e <> $${paramIndex++}::jsonb)`;
+    }
+    if (value instanceof PatchOp) {
+      params.push(JSON.stringify(value.value));
+      return `${col} = ${col} || $${paramIndex++}::jsonb`;
+    }
+    params.push(value);
+    return `${col} = $${paramIndex++}`;
+  });
+  return { setParts, params, nextParamIndex: paramIndex };
+}
+function buildSelectQuery(group, options, tableName, primaryKey) {
+  const { whereClause, params, nextParamIndex } = compilePgFilter(group, primaryKey);
+  let i = nextParamIndex;
+  const orderParts = (options?.orderBy ?? []).map((o) => `"${mapField(o.field, primaryKey)}" ${o.direction.toUpperCase()}`);
+  const orderClause = orderParts.length > 0 ? `ORDER BY ${orderParts.join(", ")}` : "";
+  let limitClause = "";
+  if (options?.limit != null) {
+    params.push(options.limit);
+    limitClause = `LIMIT $${i++}`;
+  }
+  let offsetClause = "";
+  if (options?.offset != null) {
+    params.push(options.offset);
+    offsetClause = `OFFSET $${i++}`;
+  }
+  const selectClause = options?.select?.length ? options.select.map((f) => `"${mapField(f, primaryKey)}"`).join(", ") : "*";
+  const sql = `SELECT ${selectClause} FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause} ${offsetClause}`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+function buildCountQuery(group, tableName, primaryKey) {
+  const { whereClause, params } = compilePgFilter(group, primaryKey);
+  const sql = `SELECT COUNT(*) as count FROM "${tableName}" ${whereClause}`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+function buildCreateQuery(tableName, data) {
+  const keys = Object.keys(data);
+  const params = Object.values(data);
+  const placeholders = keys.map((_, i) => `$${i + 1}`);
+  const columns = keys.map((k) => `"${k}"`).join(", ");
+  const sql = `INSERT INTO "${tableName}" (${columns}) VALUES (${placeholders.join(", ")}) RETURNING *`;
+  return { sql, params };
+}
+function buildUpdateQuery(group, tableName, primaryKey, data) {
+  const { setParts, params: setParams, nextParamIndex } = buildSetParts(data, 1);
+  const { whereClause, params: whereParams } = compilePgFilter(group, primaryKey, nextParamIndex);
+  const params = [...setParams, ...whereParams];
+  const sql = `UPDATE "${tableName}" SET ${setParts.join(", ")} ${whereClause} RETURNING *`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+function buildPkUpdateQuery(tableName, primaryKey, pk, data) {
+  const { setParts, params: setParams, nextParamIndex } = buildSetParts(data, 1);
+  setParams.push(pk);
+  const sql = `UPDATE "${tableName}" SET ${setParts.join(", ")} WHERE "${primaryKey}" = $${nextParamIndex} RETURNING *`.replace(
+    /\s+/g,
+    " "
+  );
+  return { sql, params: setParams };
+}
+function buildDeleteQuery(group, tableName, primaryKey) {
+  const { whereClause, params } = compilePgFilter(group, primaryKey);
+  const sql = `DELETE FROM "${tableName}" ${whereClause} RETURNING *`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+function buildUpsertQuery(tableName, conflictColumn, primaryKey, create, data) {
+  const columns = Object.keys(create);
+  const createParams = Object.values(create);
+  const placeholders = columns.map((_, i) => `$${i + 1}`);
+  const pgConflictCol = mapField(conflictColumn, primaryKey);
+  let setClause;
+  const allParams = [...createParams];
+  if (Object.keys(data).length > 0) {
+    const { setParts, params: setParams } = buildSetParts(data, columns.length + 1);
+    setClause = setParts.join(", ");
+    allParams.push(...setParams);
+  } else {
+    setClause = `"${pgConflictCol}" = EXCLUDED."${pgConflictCol}"`;
+  }
+  const sql = `INSERT INTO "${tableName}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT ("${pgConflictCol}") DO UPDATE SET ${setClause} RETURNING *`.replace(
+    /\s+/g,
+    " "
+  );
+  return { sql, params: allParams };
+}
+function extractUpsertConflictColumn(filter, schemaName) {
+  if (filter.children.length === 1 && filter.children[0] instanceof Filter && filter.children[0].op === "eq") {
+    return filter.children[0].field;
+  }
+  let description;
+  if (filter.children.length === 0) {
+    description = "empty filter";
+  } else if (filter.children.length === 1) {
+    const child = filter.children[0];
+    const opDesc = child instanceof Filter ? child.op : "group";
+    description = `single non-eq filter (op: ${opDesc})`;
+  } else {
+    description = `${filter.children.length} filter clauses`;
+  }
+  throw new OrmValidationError("upsert-filter-incompatible", schemaName, "upsertOne", [
+    {
+      cause: `PostgreSQL upsert requires a single eq filter on a UNIQUE-indexed column; received ${description}`
+    }
+  ]);
+}
+function aggFnToSql(fn, field, primaryKey) {
+  if (fn === "count") return "COUNT(*)";
+  const col = `"${mapField(field, primaryKey)}"`;
+  switch (fn) {
+    case "countDistinct":
+      return `COUNT(DISTINCT ${col})`;
+    case "sum":
+      return `SUM(${col})`;
+    case "avg":
+      return `AVG(${col})`;
+    case "min":
+      return `MIN(${col})`;
+    case "max":
+      return `MAX(${col})`;
+  }
+}
+function resolveHavingField(field, primaryKey, aliasToExpr, groupBySet) {
+  if (aliasToExpr.has(field)) return aliasToExpr.get(field);
+  if (groupBySet.has(field)) return `"${mapField(field, primaryKey)}"`;
+  return `"${field}"`;
+}
+function buildAggregateQuery(spec, tableName, primaryKey) {
+  const params = [];
+  let paramIndex = 1;
+  function nextParam(value) {
+    params.push(value);
+    return `$${paramIndex++}`;
+  }
+  const selectParts = [];
+  const aliasToExpr = /* @__PURE__ */ new Map();
+  for (const agg of spec.aggregates) {
+    const expr = aggFnToSql(agg.fn, agg.field, primaryKey);
+    aliasToExpr.set(agg.alias, expr);
+    selectParts.push(`${expr} AS "${agg.alias}"`);
+  }
+  const groupByFields = [];
+  for (const f of spec.groupBy) {
+    const col = `"${mapField(f, primaryKey)}"`;
+    groupByFields.push(col);
+    selectParts.push(`${col} AS "${f}"`);
+  }
+  let whereClause = "";
+  if (spec.where) {
+    const whereLeaf = (f) => compileFilter(f, primaryKey, nextParam);
+    const whereParts = compileChildren(spec.where, whereLeaf);
+    if (whereParts.length > 0) whereClause = `WHERE ${whereParts.join(" AND ")}`;
+  }
+  const groupByClause = groupByFields.length > 0 ? `GROUP BY ${groupByFields.join(", ")}` : "";
+  let havingClause = "";
+  if (spec.having) {
+    const groupBySet = new Set(spec.groupBy);
+    const havingLeaf = (f) => compileOps(f, resolveHavingField(f.field, primaryKey, aliasToExpr, groupBySet), nextParam);
+    const havingParts = compileChildren(spec.having, havingLeaf);
+    if (havingParts.length > 0) havingClause = `HAVING ${havingParts.join(" AND ")}`;
+  }
+  const sql = `SELECT ${selectParts.join(", ")} FROM "${tableName}" ${whereClause} ${groupByClause} ${havingClause}`.trim().replace(/\s+/g, " ");
+  return { sql, params };
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { FilterGroup: FilterGroup2 } = null;
+  const { OrderBy } = null;
+  const { IncOp: IncOp2, MulOp: MulOp2, MinOp: MinOp2, MaxOp: MaxOp2, UnsetOp: UnsetOp2, PushOp: PushOp2, PullOp: PullOp2, PatchOp: PatchOp2, SetOp: SetOp2, flattenOps: flattenOps2 } = null;
+  const { OrmValidationError: OrmValidationError2 } = null;
+  describe("compilePgFilter", () => {
+    test("empty filter group compiles to empty WHERE clause", () => {
+      const group = FilterGroup2.create();
+      const { sql } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users"');
+    });
+    test("single eq filter compiles to WHERE field = $1", () => {
+      const group = FilterGroup2.create().eq("name", "Alice");
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users" WHERE "name" = $1');
+      expect(params).toEqual(["Alice"]);
+    });
+    test("eq with null compiles to IS NULL", () => {
+      const group = FilterGroup2.create().eq("name", null);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users" WHERE "name" IS NULL');
+      expect(params).toEqual([]);
+    });
+    test("ne compiles to != (or IS NOT NULL for null)", () => {
+      const group = FilterGroup2.create().ne("age", 5);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users" WHERE "age" != $1');
+      expect(params).toEqual([5]);
+      const nullGroup = FilterGroup2.create().ne("age", null);
+      const { sql: nullSql } = buildSelectQuery(nullGroup, void 0, "users", "id");
+      expect(nullSql).toBe('SELECT * FROM "users" WHERE "age" IS NOT NULL');
+    });
+    test("gt, gte, lt, lte compile to >, >=, <, <=", () => {
+      expect(buildSelectQuery(FilterGroup2.create().gt("age", 10), void 0, "t", "id").sql).toContain('"age" > $1');
+      expect(buildSelectQuery(FilterGroup2.create().gte("age", 20), void 0, "t", "id").sql).toContain('"age" >= $1');
+      expect(buildSelectQuery(FilterGroup2.create().lt("age", 30), void 0, "t", "id").sql).toContain('"age" < $1');
+      expect(buildSelectQuery(FilterGroup2.create().lte("age", 40), void 0, "t", "id").sql).toContain('"age" <= $1');
+    });
+    test("in compiles to = ANY($N)", () => {
+      const group = FilterGroup2.create().in("status", ["a", "b"]);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"status" = ANY($1)');
+      expect(params).toEqual([["a", "b"]]);
+    });
+    test("notIn compiles to NOT (field = ANY($N)) \u2014 canonical name notIn", () => {
+      const group = FilterGroup2.create().notIn("status", ["x", "y"]);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('NOT ("status" = ANY($1))');
+      expect(params).toEqual([["x", "y"]]);
+    });
+    test("like compiles to ILIKE with % wrapping", () => {
+      const group = FilterGroup2.create().like("name", "ali");
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"name" ILIKE $1');
+      expect(params).toEqual(["%ali%"]);
+    });
+    test("exists compiles to IS NOT NULL (own op, not boolean form)", () => {
+      const group = FilterGroup2.create().exists("val");
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"val" IS NOT NULL');
+      expect(params).toEqual([]);
+    });
+    test("notExists is its own op \u2014 compiles to IS NULL", () => {
+      const group = FilterGroup2.create().notExists("val");
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"val" IS NULL');
+      expect(params).toEqual([]);
+    });
+    test("contains compiles to @> jsonb", () => {
+      const group = FilterGroup2.create().contains("tags", ["a", "b"]);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('"tags" @> $1::jsonb');
+      expect(params).toEqual([JSON.stringify(["a", "b"])]);
+    });
+    test("notContains compiles to NOT (@> jsonb)", () => {
+      const group = FilterGroup2.create().notContains("tags", ["x"]);
+      const { sql, params } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toContain('NOT ("tags" @> $1::jsonb)');
+      expect(params).toEqual([JSON.stringify(["x"])]);
+    });
+    test("multiple clauses produce AND-joined WHERE", () => {
+      const group = FilterGroup2.create().eq("a", 1).gt("b", 2);
+      const { sql } = buildSelectQuery(group, void 0, "t", "id");
+      expect(sql).toContain('WHERE "a" = $1 AND "b" > $2');
+    });
+    test("nested and/or groups compile correctly", () => {
+      const group = FilterGroup2.create().and([
+        (q) => q.eq("a", 1),
+        (q) => q.or([(g) => g.eq("b", 2), (g) => g.eq("c", 3)])
+      ]);
+      const { sql, params } = buildSelectQuery(group, void 0, "t", "id");
+      expect(sql).toContain('("a" = $1 AND ("b" = $2 OR "c" = $3))');
+      expect(params).toEqual([1, 2, 3]);
+    });
+    test("maps id field to primaryKey when primaryKey differs", () => {
+      const group = FilterGroup2.create().eq("id", "abc");
+      const { sql } = buildSelectQuery(group, void 0, "users", "user_id");
+      expect(sql).toContain('"user_id" = $1');
+    });
+  });
+  describe("buildSelectQuery", () => {
+    test("options: sort, limit, offset, select", () => {
+      const group = FilterGroup2.create().eq("active", true);
+      const options = {
+        orderBy: [new OrderBy("name", "asc"), new OrderBy("age", "desc")],
+        limit: 10,
+        offset: 5,
+        select: ["name", "age"]
+      };
+      const { sql, params } = buildSelectQuery(group, options, "users", "id");
+      expect(sql).toContain('SELECT "name", "age"');
+      expect(sql).toContain('ORDER BY "name" ASC, "age" DESC');
+      expect(sql).toContain("LIMIT $2");
+      expect(sql).toContain("OFFSET $3");
+      expect(params).toEqual([true, 10, 5]);
+    });
+    test("undefined options returns basic SELECT *", () => {
+      const group = FilterGroup2.create().eq("x", 1);
+      const { sql } = buildSelectQuery(group, void 0, "users", "id");
+      expect(sql).toBe('SELECT * FROM "users" WHERE "x" = $1');
+    });
+  });
+  describe("buildCreateQuery", () => {
+    test("produces INSERT with RETURNING *", () => {
+      const { sql, params } = buildCreateQuery("users", { name: "Alice", age: 30 });
+      expect(sql).toBe('INSERT INTO "users" ("name", "age") VALUES ($1, $2) RETURNING *');
+      expect(params).toEqual(["Alice", 30]);
+    });
+  });
+  describe("buildUpdateQuery", () => {
+    test("plain values produce SET col = $N", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql, params } = buildUpdateQuery(group, "users", "id", { name: "Bob", age: 25 });
+      expect(sql).toBe('UPDATE "users" SET "name" = $1, "age" = $2 WHERE "id" = $3 RETURNING *');
+      expect(params).toEqual(["Bob", 25, "u1"]);
+    });
+    test("IncOp produces col = col + $N", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql, params } = buildUpdateQuery(group, "users", "id", { count: new IncOp2("count", 5) });
+      expect(sql).toContain('"count" = "count" + $1');
+      expect(params[0]).toBe(5);
+    });
+    test("MulOp produces col = col * $N", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { score: new MulOp2("score", 2) });
+      expect(sql).toContain('"score" = "score" * $1');
+    });
+    test("MinOp/MaxOp produce LEAST/GREATEST", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", {
+        lo: new MinOp2("lo", 1),
+        hi: new MaxOp2("hi", 99)
+      });
+      expect(sql).toContain('LEAST("lo", $1)');
+      expect(sql).toContain('GREATEST("hi", $2)');
+    });
+    test("UnsetOp produces col = NULL", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { old: new UnsetOp2("old") });
+      expect(sql).toContain('"old" = NULL');
+    });
+    test("PushOp produces jsonb array append", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { tags: new PushOp2("tags", "new") });
+      expect(sql).toContain("jsonb_build_array($1::jsonb)");
+    });
+    test("PullOp produces jsonb array removal", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { tags: new PullOp2("tags", "old") });
+      expect(sql).toContain("jsonb_array_elements");
+    });
+    test("PatchOp produces jsonb merge", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql } = buildUpdateQuery(group, "users", "id", { meta: new PatchOp2("meta", { a: 1 }) });
+      expect(sql).toContain("|| $1::jsonb");
+    });
+  });
+  describe("buildPkUpdateQuery", () => {
+    test("builds UPDATE with PK WHERE clause", () => {
+      const { sql, params } = buildPkUpdateQuery("users", "id", "u1", { name: "Bob" });
+      expect(sql).toBe('UPDATE "users" SET "name" = $1 WHERE "id" = $2 RETURNING *');
+      expect(params).toEqual(["Bob", "u1"]);
+    });
+    test("handles ops in PK update", () => {
+      const { sql, params } = buildPkUpdateQuery("users", "id", "u1", { count: new IncOp2("count", 3) });
+      expect(sql).toContain('"count" = "count" + $1');
+      expect(sql).toContain('WHERE "id" = $2');
+      expect(params).toEqual([3, "u1"]);
+    });
+  });
+  describe("buildDeleteQuery", () => {
+    test("produces DELETE with RETURNING *", () => {
+      const group = FilterGroup2.create().eq("id", "u1");
+      const { sql, params } = buildDeleteQuery(group, "users", "id");
+      expect(sql).toBe('DELETE FROM "users" WHERE "id" = $1 RETURNING *');
+      expect(params).toEqual(["u1"]);
+    });
+  });
+  describe("buildUpsertQuery", () => {
+    test("produces INSERT ON CONFLICT with SET parts from data", () => {
+      const data = flattenOps2([new SetOp2({ name: "Updated" })]);
+      const { sql, params } = buildUpsertQuery("users", "email", "id", { id: "u1", email: "a@b.com", name: "Alice" }, data);
+      expect(sql).toContain('INSERT INTO "users"');
+      expect(sql).toContain('ON CONFLICT ("email") DO UPDATE SET');
+      expect(sql).toContain('"name" = $4');
+      expect(sql).toContain("RETURNING *");
+      expect(params).toEqual(["u1", "a@b.com", "Alice", "Updated"]);
+    });
+    test("empty data produces no-op SET on conflict column", () => {
+      const { sql, params } = buildUpsertQuery("users", "email", "id", { id: "u1", email: "a@b.com" }, {});
+      expect(sql).toContain('ON CONFLICT ("email") DO UPDATE SET "email" = EXCLUDED."email"');
+      expect(params).toEqual(["u1", "a@b.com"]);
+    });
+    test("maps conflict column via mapField when primaryKey differs", () => {
+      const { sql } = buildUpsertQuery("users", "id", "user_id", { user_id: "u1", name: "A" }, {});
+      expect(sql).toContain('ON CONFLICT ("user_id")');
+    });
+    test("handles ops in upsert SET clause", () => {
+      const data = flattenOps2([new IncOp2("views", 1)]);
+      const { sql, params } = buildUpsertQuery("posts", "slug", "id", { id: "p1", slug: "hello", views: 0 }, data);
+      expect(sql).toContain('"views" = "views" + $4');
+      expect(params).toEqual(["p1", "hello", 0, 1]);
+    });
+  });
+  describe("extractUpsertConflictColumn", () => {
+    test("extracts field from single eq filter", () => {
+      const filter = FilterGroup2.create().eq("email", "a@b.com");
+      expect(extractUpsertConflictColumn(filter, "users")).toBe("email");
+    });
+    test("throws upsert-filter-incompatible on empty filter", () => {
+      const filter = FilterGroup2.create();
+      expect(() => extractUpsertConflictColumn(filter, "users")).toThrow(OrmValidationError2);
+      try {
+        extractUpsertConflictColumn(filter, "users");
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("upsert-filter-incompatible");
+        expect(err.schema).toBe("users");
+        expect(err.operation).toBe("upsertOne");
+        expect(err.failures[0].cause).toContain("empty filter");
+      }
+    });
+    test("throws upsert-filter-incompatible on multiple filters", () => {
+      const filter = FilterGroup2.create().eq("a", 1).eq("b", 2);
+      expect(() => extractUpsertConflictColumn(filter, "users")).toThrow(OrmValidationError2);
+      try {
+        extractUpsertConflictColumn(filter, "users");
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("upsert-filter-incompatible");
+        expect(err.failures[0].cause).toContain("2 filter clauses");
+      }
+    });
+    test("throws upsert-filter-incompatible on non-eq filter", () => {
+      const filter = FilterGroup2.create().gt("age", 10);
+      expect(() => extractUpsertConflictColumn(filter, "users")).toThrow(OrmValidationError2);
+      try {
+        extractUpsertConflictColumn(filter, "users");
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("upsert-filter-incompatible");
+        expect(err.failures[0].cause).toContain("non-eq filter");
+      }
+    });
+    test("throws with clear message naming received filter shape", () => {
+      const filter = FilterGroup2.create().in("status", ["a", "b"]);
+      try {
+        extractUpsertConflictColumn(filter, "test");
+        expect.unreachable();
+      } catch (e) {
+        const err = e;
+        expect(err.kind).toBe("upsert-filter-incompatible");
+        expect(err.failures[0].cause).toContain("single eq filter");
+        expect(err.failures[0].cause).toContain("UNIQUE-indexed column");
+      }
+    });
+  });
+  describe("buildAggregateQuery", () => {
+    test("bare count produces SELECT COUNT(*) AS alias", () => {
+      const { sql, params } = buildAggregateQuery(
+        { aggregates: [{ fn: "count", alias: "total" }], groupBy: [] },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe('SELECT COUNT(*) AS "total" FROM "orders"');
+      expect(params).toEqual([]);
+    });
+    test("multi-aggregator produces all functions", () => {
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [
+            { fn: "count", alias: "cnt" },
+            { fn: "sum", field: "amount", alias: "revenue" },
+            { fn: "avg", field: "amount", alias: "avgAmt" },
+            { fn: "min", field: "amount", alias: "lo" },
+            { fn: "max", field: "amount", alias: "hi" }
+          ],
+          groupBy: []
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT COUNT(*) AS "cnt", SUM("amount") AS "revenue", AVG("amount") AS "avgAmt", MIN("amount") AS "lo", MAX("amount") AS "hi" FROM "orders"'
+      );
+      expect(params).toEqual([]);
+    });
+    test("countDistinct produces COUNT(DISTINCT col)", () => {
+      const { sql } = buildAggregateQuery(
+        { aggregates: [{ fn: "countDistinct", field: "category", alias: "unique" }], groupBy: [] },
+        "items",
+        "id"
+      );
+      expect(sql).toBe('SELECT COUNT(DISTINCT "category") AS "unique" FROM "items"');
+    });
+    test("single-column groupBy produces GROUP BY clause", () => {
+      const { sql } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["region"]
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe('SELECT COUNT(*) AS "cnt", "region" AS "region" FROM "orders" GROUP BY "region"');
+    });
+    test("multi-column groupBy produces all GROUP BY columns", () => {
+      const { sql } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["region", "product"]
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT COUNT(*) AS "cnt", "region" AS "region", "product" AS "product" FROM "orders" GROUP BY "region", "product"'
+      );
+    });
+    test("where-only produces WHERE clause with params", () => {
+      const where = FilterGroup2.create().eq("status", "active");
+      const { sql, params } = buildAggregateQuery(
+        { aggregates: [{ fn: "count", alias: "total" }], groupBy: [], where },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe('SELECT COUNT(*) AS "total" FROM "orders" WHERE "status" = $1');
+      expect(params).toEqual(["active"]);
+    });
+    test("having-only filters on aggregate alias via repeated expression", () => {
+      const having = FilterGroup2.create().gt("total", 10);
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "total" }],
+          groupBy: ["region"],
+          having
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT COUNT(*) AS "total", "region" AS "region" FROM "orders" GROUP BY "region" HAVING COUNT(*) > $1'
+      );
+      expect(params).toEqual([10]);
+    });
+    test("where + having both produce correct param ordering", () => {
+      const where = FilterGroup2.create().eq("status", "active");
+      const having = FilterGroup2.create().gte("revenue", 1e3);
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "sum", field: "amount", alias: "revenue" }],
+          groupBy: ["region"],
+          where,
+          having
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT SUM("amount") AS "revenue", "region" AS "region" FROM "orders" WHERE "status" = $1 GROUP BY "region" HAVING SUM("amount") >= $2'
+      );
+      expect(params).toEqual(["active", 1e3]);
+    });
+    test("having on groupBy field uses column name directly", () => {
+      const having = FilterGroup2.create().eq("region", "US");
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["region"],
+          having
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toBe(
+        'SELECT COUNT(*) AS "cnt", "region" AS "region" FROM "orders" GROUP BY "region" HAVING "region" = $1'
+      );
+      expect(params).toEqual(["US"]);
+    });
+    test("field-name mapping: id maps to primaryKey when primaryKey differs", () => {
+      const { sql } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "countDistinct", field: "id", alias: "uniqueIds" }],
+          groupBy: []
+        },
+        "users",
+        "user_id"
+      );
+      expect(sql).toBe('SELECT COUNT(DISTINCT "user_id") AS "uniqueIds" FROM "users"');
+    });
+    test("groupBy with id field maps to primaryKey", () => {
+      const { sql } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["id"]
+        },
+        "users",
+        "user_id"
+      );
+      expect(sql).toContain('GROUP BY "user_id"');
+      expect(sql).toContain('"user_id" AS "id"');
+    });
+    test("complex having with AND/OR groups", () => {
+      const having = FilterGroup2.create().and([
+        (q) => q.gt("cnt", 5),
+        (q) => q.or([(g) => g.eq("region", "US"), (g) => g.eq("region", "EU")])
+      ]);
+      const { sql, params } = buildAggregateQuery(
+        {
+          aggregates: [{ fn: "count", alias: "cnt" }],
+          groupBy: ["region"],
+          having
+        },
+        "orders",
+        "id"
+      );
+      expect(sql).toContain('HAVING (COUNT(*) > $1 AND ("region" = $2 OR "region" = $3))');
+      expect(params).toEqual([5, "US", "EU"]);
+    });
+  });
+}
+
+// src/orm/adapters/postgresql/index.ts
+init_errors();
+init_utilities();
+
+// src/orm/orm-adapter.ts
+init_errors();
+init_instance();
+var OrmAdapter = class {
+  queryableOps = [];
+  updateOps = [];
+  aggregateOps = [];
+  supportedFieldTypes = [];
+  onFatalError(err) {
+    const wrapped = err instanceof EquippedError ? err : new EquippedError("OrmAdapter fatal error", {}, err);
+    Instance.crash(wrapped);
+  }
+  constructor() {
+    const self = this;
+    if (typeof self.connect === "function") {
+      Instance.on("start", () => self.connect(), { class: this.constructor });
+    }
+    if (typeof self.disconnect === "function") {
+      Instance.on("close", () => self.disconnect(), { class: this.constructor });
+    }
+  }
+  use(schema, config) {
+    const self = this;
+    const emptyIterator = async function* () {
+    };
+    const use = {
+      findMany: (filter, opts) => self.findMany?.(schema, config, filter, opts) ?? Promise.resolve([]),
+      iterateMany: (filter, opts) => self.iterateMany?.(schema, config, filter, opts) ?? emptyIterator(),
+      findOne: async (filter) => {
+        const rows = await use.findMany(filter, { limit: 1 });
+        return rows[0] ?? null;
+      },
+      count: (filter) => self.count?.(schema, config, filter) ?? Promise.reject(new Error("count not implemented")),
+      createOne: async (d) => {
+        const rows = await use.createMany([d]);
+        return rows[0];
+      },
+      createMany: (d) => self.createMany?.(schema, config, d) ?? Promise.resolve([]),
+      updateMany: (filter, d) => self.updateMany?.(schema, config, filter, d) ?? Promise.resolve([]),
+      updateOne: async (filter, d) => {
+        const match = await use.findOne(filter);
+        if (!match) return null;
+        const pk = schema.pkField.name;
+        const pkFilter = FilterGroup.create().eq(pk, match[pk]);
+        const rows = await use.updateMany(pkFilter, d);
+        return rows[0] ?? null;
+      },
+      upsertOne: (filter, create, ops) => self.upsertOne?.(schema, config, filter, create, ops) ?? Promise.reject(new Error("upsertOne not implemented")),
+      deleteOne: async (filter) => {
+        const row = await use.findOne(filter);
+        if (!row) return null;
+        const pk = schema.pkField.name;
+        if (self.deleteByPk) {
+          await self.deleteByPk(schema, config, row[pk]);
+        } else if (self.deleteMany) {
+          const pkFilter = FilterGroup.create().eq(pk, row[pk]);
+          await self.deleteMany(schema, config, pkFilter);
+        }
+        return row;
+      },
+      deleteMany: (filter) => self.deleteMany?.(schema, config, filter) ?? Promise.resolve([]),
+      raw: (...args) => self.raw?.(schema, config, ...args) ?? Promise.reject(new Error("raw not implemented")),
+      aggregate: (spec) => self.aggregate?.(schema, config, spec) ?? Promise.reject(new Error("aggregate not implemented")),
+      aggregateOps: self.aggregateOps ?? []
+    };
+    return use;
+  }
+};
+if (void 0) {
+  const { describe, test, expect, vi } = void 0;
+  const { v: v6 } = null;
+  describe("OrmAdapter", () => {
+    test("subclass with connect/disconnect auto-registers Instance hooks", async () => {
+      const { Instance: Inst } = await null;
+      const onSpy = vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      class TestAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        supportedFieldTypes = ["string"];
+        async connect() {
+        }
+        async disconnect() {
+        }
+      }
+      new TestAdapter();
+      expect(onSpy).toHaveBeenCalledWith("start", expect.any(Function), expect.objectContaining({ class: TestAdapter }));
+      expect(onSpy).toHaveBeenCalledWith("close", expect.any(Function), expect.objectContaining({ class: TestAdapter }));
+      onSpy.mockRestore();
+    });
+    test("subclass without connect/disconnect does not register hooks", async () => {
+      const { Instance: Inst } = await null;
+      const onSpy = vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      class MinimalAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+      }
+      new MinimalAdapter();
+      expect(onSpy).not.toHaveBeenCalled();
+      onSpy.mockRestore();
+    });
+    test("capability declarations default to empty arrays", async () => {
+      const { Instance: Inst } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      class DefaultAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+      }
+      const adapter = new DefaultAdapter();
+      expect(adapter.queryableOps).toEqual([]);
+      expect(adapter.updateOps).toEqual([]);
+      expect(adapter.aggregateOps).toEqual([]);
+      expect(adapter.supportedFieldTypes).toEqual([]);
+      vi.restoreAllMocks();
+    });
+    test("onFatalError wraps non-EquippedError and calls Instance.crash", async () => {
+      const { Instance: Inst } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      const crashSpy = vi.spyOn(Inst, "crash").mockImplementation((() => {
+        throw new Error("crash");
+      }));
+      class FatalAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        triggerFatal() {
+          this.onFatalError(new Error("something broke"));
+        }
+      }
+      const adapter = new FatalAdapter();
+      expect(() => adapter.triggerFatal()).toThrow("crash");
+      expect(crashSpy).toHaveBeenCalled();
+      vi.restoreAllMocks();
+    });
+    test("onFatalError passes through EquippedError directly", async () => {
+      const { Instance: Inst } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      let crashedWith;
+      vi.spyOn(Inst, "crash").mockImplementation(((err) => {
+        crashedWith = err;
+        throw err;
+      }));
+      class FatalAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        triggerFatal() {
+          this.onFatalError(new EquippedError("equipped error", { detail: "test" }));
+        }
+      }
+      const adapter = new FatalAdapter();
+      expect(() => adapter.triggerFatal()).toThrow();
+      expect(crashedWith).toBeInstanceOf(EquippedError);
+      expect(crashedWith.message).toBe("equipped error");
+      vi.restoreAllMocks();
+    });
+    test("use() creates OrmUse bridge that delegates to flat methods", async () => {
+      const { Instance: Inst } = await null;
+      const { Schema } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      class BridgeAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        supportedFieldTypes = ["string"];
+        queryableOps = ["eq"];
+        async findMany(_s, _c, _f, _o) {
+          return [{ id: "found" }];
+        }
+        async count(_s, _c, _f) {
+          return 1;
+        }
+        async *iterateMany(_s, _c, _f, _o) {
+          yield { id: "iterated" };
+        }
+        async createMany(_s, _c, data) {
+          return data;
+        }
+      }
+      const TestSchema = Schema.from("bridge_test").pk("id", v6.string(), () => "x").build();
+      const adapter = new BridgeAdapter();
+      const ormUse = adapter.use(TestSchema, { table: "bridge_test" });
+      const rows = await ormUse.findMany(FilterGroup.create());
+      expect(rows).toEqual([{ id: "found" }]);
+      await expect(ormUse.count(FilterGroup.create())).resolves.toBe(1);
+      const iterated = [];
+      for await (const row of ormUse.iterateMany(FilterGroup.create())) iterated.push(row);
+      expect(iterated).toEqual([{ id: "iterated" }]);
+      const created = await ormUse.createOne({ id: "new" });
+      expect(created).toEqual({ id: "new" });
+      vi.restoreAllMocks();
+    });
+    test("use() bridge delegates updateMany to flat method", async () => {
+      const { Instance: Inst } = await null;
+      const { Schema } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      class UpdateAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        supportedFieldTypes = ["string", "number"];
+        updateOps = ["set"];
+        async findMany(_s, _c, _f) {
+          return [{ id: "u1", name: "old" }];
+        }
+        async updateMany(_s, _c, _f, data) {
+          return [{ id: "u1", ...data }];
+        }
+      }
+      const TestSchema = Schema.from("upd_test").pk("id", v6.string(), () => "x").field("name", v6.string()).build();
+      const adapter = new UpdateAdapter();
+      const ormUse = adapter.use(TestSchema, { table: "upd_test" });
+      const updated = await ormUse.updateOne(FilterGroup.create().eq("id", "u1"), { name: "new" });
+      expect(updated).not.toBeNull();
+      expect(updated.name).toBe("new");
+      vi.restoreAllMocks();
+    });
+    test("use().iterateMany does not fall back to findMany when adapter omits iterateMany", async () => {
+      const { Instance: Inst } = await null;
+      const { Schema } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      let findManyCalls = 0;
+      class FindOnlyAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        supportedFieldTypes = ["string"];
+        async findMany() {
+          findManyCalls += 1;
+          return [{ id: "found" }];
+        }
+      }
+      const TestSchema = Schema.from("iter_no_fallback").pk("id", v6.string(), () => "x").build();
+      const adapter = new FindOnlyAdapter();
+      const rows = [];
+      for await (const row of adapter.use(TestSchema, { table: "iter_no_fallback" }).iterateMany(FilterGroup.create())) rows.push(row);
+      expect(rows).toEqual([]);
+      expect(findManyCalls).toBe(0);
+      vi.restoreAllMocks();
+    });
+    test("use() bridge delegates deleteByPk via deleteOne", async () => {
+      const { Instance: Inst } = await null;
+      const { Schema } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      let deletedPk = null;
+      class DeleteAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        supportedFieldTypes = ["string"];
+        async findMany(_s, _c, _f) {
+          return [{ id: "d1" }];
+        }
+        async deleteByPk(_s, _c, pk) {
+          deletedPk = pk;
+          return { id: String(pk) };
+        }
+      }
+      const TestSchema = Schema.from("del_test").pk("id", v6.string(), () => "x").build();
+      const adapter = new DeleteAdapter();
+      const ormUse = adapter.use(TestSchema, { table: "del_test" });
+      const deleted = await ormUse.deleteOne(FilterGroup.create().eq("id", "d1"));
+      expect(deleted).toEqual({ id: "d1" });
+      expect(deletedPk).toBe("d1");
+      vi.restoreAllMocks();
+    });
+    test("use() bridge delegates session to flat method", async () => {
+      const { Instance: Inst } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      let sessionRan = false;
+      class SessionAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        async session(fn) {
+          sessionRan = true;
+          return fn();
+        }
+      }
+      const adapter = new SessionAdapter();
+      const result = await adapter.session(async () => 42);
+      expect(result).toBe(42);
+      expect(sessionRan).toBe(true);
+      vi.restoreAllMocks();
+    });
+    test("type-level: subclass method override enforces canonical signature", async () => {
+      const { Instance: Inst } = await null;
+      vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      class CorrectAdapter extends OrmAdapter {
+        schemaConfigPipe = v6.object({ table: v6.string() });
+        async findByPk(_s, _c, _pk) {
+          return null;
+        }
+        async createMany(_s, _c, _d) {
+          return [];
+        }
+        async raw(_s, _c, ..._args) {
+          return null;
+        }
+      }
+      const adapter = new CorrectAdapter();
+      expect(adapter.findByPk).toBeTypeOf("function");
+      expect(adapter.createMany).toBeTypeOf("function");
+      expect(adapter.raw).toBeTypeOf("function");
+      vi.restoreAllMocks();
+    });
+  });
+}
+
+// src/orm/adapters/postgresql/index.ts
+var postgresqlConnectionPipe = () => import_valleyed5.v.object({
+  host: import_valleyed5.v.string(),
+  port: import_valleyed5.v.number(),
+  username: import_valleyed5.v.string(),
+  password: import_valleyed5.v.string(),
+  database: import_valleyed5.v.string(),
+  ssl: import_valleyed5.v.defaults(import_valleyed5.v.boolean(), false)
+});
+var TRACKER_TABLE = "equipped_migrations";
+var ADVISORY_LOCK_KEY = 3735928559;
+var DEFAULT_CURSOR_BATCH_SIZE = 1e3;
+var FIELD_TYPE_TO_PG = {
+  string: "text",
+  number: "double precision",
+  boolean: "boolean",
+  date: "timestamptz",
+  null: "text",
+  object: "jsonb",
+  array: "jsonb"
+};
+var PG_TO_FIELD_TYPE = {
+  text: "string",
+  "character varying": "string",
+  varchar: "string",
+  char: "string",
+  character: "string",
+  "double precision": "number",
+  real: "number",
+  integer: "number",
+  smallint: "number",
+  numeric: "number",
+  decimal: "number",
+  boolean: "boolean",
+  "timestamp with time zone": "date",
+  "timestamp without time zone": "date",
+  timestamptz: "date",
+  timestamp: "date",
+  date: "date",
+  jsonb: "object",
+  json: "object"
+};
+var PostgresAdapter = class extends configurable(postgresqlConnectionPipe, OrmAdapter) {
+  schemaConfigPipe = import_valleyed5.v.object({
+    schema: import_valleyed5.v.optional(import_valleyed5.v.string()),
+    table: import_valleyed5.v.string()
+  });
+  supportedFieldTypes = ["string", "number", "boolean", "null", "object", "array", "date"];
+  queryableOps = [
+    "eq",
+    "ne",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "in",
+    "notIn",
+    "like",
+    "exists",
+    "notExists",
+    "contains",
+    "notContains"
+  ];
+  updateOps = ["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"];
+  aggregateOps = ["count", "countDistinct", "sum", "avg", "min", "max"];
+  pool;
+  #sessionStore = new import_node_async_hooks.AsyncLocalStorage();
+  constructor(config) {
+    super(config);
+    this.pool = new import_pg.Pool({
+      host: config.host,
+      port: config.port,
+      user: config.username,
+      password: config.password,
+      database: config.database,
+      ssl: config.ssl ? { rejectUnauthorized: false } : false
+    });
+  }
+  #getClient() {
+    return this.#sessionStore.getStore() ?? this.pool;
+  }
+  #resolveTableName(config) {
+    return config.schema && config.schema !== "public" ? `${config.schema}.${config.table}` : config.table;
+  }
+  async connect() {
+  }
+  async disconnect() {
+    try {
+      await this.pool.end();
+    } catch (error) {
+      throw new EquippedError("Failed to disconnect PostgreSQL pool", { adapter: "postgresql" }, error);
+    }
+  }
+  async findByPk(schema, config, pk) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const pkName = schema.pkField.name;
+      const result = await this.#getClient().query(`SELECT * FROM "${tableName}" WHERE "${pkName}" = $1`, [pk]);
+      return result.rows[0] ?? null;
+    } catch (error) {
+      throw new EquippedError("PostgreSQL findByPk failed", { adapter: "postgresql", operation: "findByPk", table: c.table }, error);
+    }
+  }
+  async createMany(_schema, config, data) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const client = this.#getClient();
+      const results = [];
+      for (const doc of data) {
+        const { sql, params } = buildCreateQuery(tableName, doc);
+        const result = await client.query(sql, params);
+        results.push(result.rows[0]);
+      }
+      return results;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL createMany failed",
+        { adapter: "postgresql", operation: "createMany", table: c.table },
+        error
+      );
+    }
+  }
+  async updateByPk(schema, config, pk, ops) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const pkName = schema.pkField.name;
+      const data = flattenOps(ops);
+      if (Object.keys(data).length === 0) {
+        const result2 = await this.#getClient().query(`SELECT * FROM "${tableName}" WHERE "${pkName}" = $1`, [pk]);
+        return result2.rows[0] ?? null;
+      }
+      const { sql, params } = buildPkUpdateQuery(tableName, pkName, pk, data);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows[0] ?? null;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL updateByPk failed",
+        { adapter: "postgresql", operation: "updateByPk", table: c.table },
+        error
+      );
+    }
+  }
+  async deleteByPk(schema, config, pk) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const pkName = schema.pkField.name;
+      const result = await this.#getClient().query(`DELETE FROM "${tableName}" WHERE "${pkName}" = $1 RETURNING *`, [pk]);
+      return result.rows[0] ?? null;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL deleteByPk failed",
+        { adapter: "postgresql", operation: "deleteByPk", table: c.table },
+        error
+      );
+    }
+  }
+  async raw(_schema, config, command, params = []) {
+    const c = config;
+    try {
+      const result = await this.#getClient().query(command, params);
+      return result;
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("PostgreSQL raw failed", { adapter: "postgresql", operation: "raw", table: c.table }, error);
+    }
+  }
+  async findMany(schema, config, filter, options) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildSelectQuery(filter, options, tableName, schema.pkField.name);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows;
+    } catch (error) {
+      throw new EquippedError("PostgreSQL findMany failed", { adapter: "postgresql", operation: "findMany", table: c.table }, error);
+    }
+  }
+  async count(schema, config, filter) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildCountQuery(filter, tableName, schema.pkField.name);
+      const result = await this.#getClient().query(sql, params);
+      return Number(result.rows[0]?.count ?? 0);
+    } catch (error) {
+      throw new EquippedError("PostgreSQL count failed", { adapter: "postgresql", operation: "count", table: c.table }, error);
+    }
+  }
+  async *iterateMany(schema, config, filter, options) {
+    const c = config;
+    let client;
+    let releaseClient = false;
+    let cursor;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildSelectQuery(filter, options, tableName, schema.pkField.name);
+      const sessionClient = this.#sessionStore.getStore();
+      if (sessionClient) {
+        client = sessionClient;
+      } else {
+        client = await this.pool.connect();
+        releaseClient = true;
+      }
+      cursor = client.query(new import_pg_cursor.default(sql, params));
+      const batchSize = options?.batchSize ?? DEFAULT_CURSOR_BATCH_SIZE;
+      while (true) {
+        const rows = await cursor.read(batchSize);
+        if (rows.length === 0) break;
+        for (const row of rows) yield row;
+      }
+    } catch (error) {
+      throw new EquippedError("PostgreSQL iterateMany failed", { adapter: "postgresql", operation: "iterateMany", table: c.table }, error);
+    } finally {
+      try {
+        await cursor?.close();
+      } finally {
+        if (releaseClient) client?.release();
+      }
+    }
+  }
+  async updateMany(schema, config, filter, data) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildUpdateQuery(filter, tableName, schema.pkField.name, data);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL updateMany failed",
+        { adapter: "postgresql", operation: "updateMany", table: c.table },
+        error
+      );
+    }
+  }
+  async deleteMany(schema, config, filter) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildDeleteQuery(filter, tableName, schema.pkField.name);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows;
+    } catch (error) {
+      throw new EquippedError(
+        "PostgreSQL deleteMany failed",
+        { adapter: "postgresql", operation: "deleteMany", table: c.table },
+        error
+      );
+    }
+  }
+  async upsertOne(schema, config, filter, create, ops) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const conflictColumn = extractUpsertConflictColumn(filter, schema.name);
+      const data = ops.length > 0 ? flattenOps(ops) : {};
+      const { sql, params } = buildUpsertQuery(tableName, conflictColumn, schema.pkField.name, create, data);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows[0];
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("PostgreSQL upsertOne failed", { adapter: "postgresql", operation: "upsertOne", table: c.table }, error);
+    }
+  }
+  async aggregate(schema, config, spec) {
+    const c = config;
+    try {
+      const tableName = this.#resolveTableName(c);
+      const { sql, params } = buildAggregateQuery(spec, tableName, schema.pkField.name);
+      const result = await this.#getClient().query(sql, params);
+      return result.rows.map((row) => {
+        const mapped = {};
+        for (const agg of spec.aggregates) {
+          const val = row[agg.alias];
+          if (agg.fn === "min" || agg.fn === "max") {
+            mapped[agg.alias] = val;
+          } else {
+            mapped[agg.alias] = typeof val === "string" ? Number(val) : Number(val ?? 0);
+          }
+        }
+        for (const field of spec.groupBy) {
+          mapped[field] = row[field];
+        }
+        return mapped;
+      });
+    } catch (error) {
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("PostgreSQL aggregate failed", { adapter: "postgresql", operation: "aggregate", table: c.table }, error);
+    }
+  }
+  async loadMigrations() {
+    const client = this.#getClient();
+    await client.query(`
+			CREATE TABLE IF NOT EXISTS "${TRACKER_TABLE}" (
+				id text PRIMARY KEY,
+				applied_at bigint NOT NULL
+			)
+		`);
+    const result = await client.query(`SELECT id, applied_at FROM "${TRACKER_TABLE}"`);
+    return result.rows.map((row) => ({ id: row.id, appliedAt: Number(row.applied_at) }));
+  }
+  async recordMigration(id, appliedAt) {
+    const client = this.#getClient();
+    await client.query(`INSERT INTO "${TRACKER_TABLE}" (id, applied_at) VALUES ($1, $2)`, [id, appliedAt]);
+  }
+  async acquireMigrationLock(fn) {
+    const client = this.#getClient();
+    await client.query(`SELECT pg_advisory_lock($1)`, [ADVISORY_LOCK_KEY]);
+    try {
+      return await fn();
+    } finally {
+      await client.query(`SELECT pg_advisory_unlock($1)`, [ADVISORY_LOCK_KEY]);
+    }
+  }
+  async applyCreateTable(change) {
+    const pkType = FIELD_TYPE_TO_PG[change.pk.type] ?? "text";
+    const cols = [`"${change.pk.name}" ${pkType} PRIMARY KEY`];
+    for (const f of change.fields) {
+      cols.push(this.#renderColumnDef(f));
+    }
+    await this.#getClient().query(`CREATE TABLE "${change.name}" (${cols.join(", ")})`);
+  }
+  async applyDropTable(change) {
+    await this.#getClient().query(`DROP TABLE "${change.name}"`);
+  }
+  async applyAddField(change) {
+    const colDef = this.#renderColumnDef(change.field);
+    await this.#getClient().query(`ALTER TABLE "${change.table}" ADD COLUMN ${colDef}`);
+  }
+  async applyDropField(change) {
+    await this.#getClient().query(`ALTER TABLE "${change.table}" DROP COLUMN "${change.name}"`);
+  }
+  async applyModifyField(change) {
+    const client = this.#getClient();
+    const table = `"${change.table}"`;
+    const col = `"${change.name}"`;
+    const newType = FIELD_TYPE_TO_PG[change.to.type] ?? "text";
+    await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} TYPE ${newType} USING ${col}::${newType}`);
+    if (change.to.nullable) {
+      await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} DROP NOT NULL`);
+    } else {
+      await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} SET NOT NULL`);
+    }
+    if (change.to.default !== void 0) {
+      await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} SET DEFAULT ${this.#renderDefault(change.to.default)}`);
+    } else {
+      await client.query(`ALTER TABLE ${table} ALTER COLUMN ${col} DROP DEFAULT`);
+    }
+    if (change.to.name !== change.name) {
+      await client.query(`ALTER TABLE ${table} RENAME COLUMN ${col} TO "${change.to.name}"`);
+    }
+  }
+  async applyRenameTable(change) {
+    await this.#getClient().query(`ALTER TABLE "${change.from}" RENAME TO "${change.to}"`);
+  }
+  async applyRenameField(change) {
+    await this.#getClient().query(`ALTER TABLE "${change.table}" RENAME COLUMN "${change.from}" TO "${change.to}"`);
+  }
+  async applyAddIndex(change) {
+    const name = change.name ?? this.#deriveIndexName(change.table, change.on, change.unique);
+    const unique = change.unique ? "UNIQUE " : "";
+    const cols = change.on.map((c) => `"${c}"`).join(", ");
+    await this.#getClient().query(`CREATE ${unique}INDEX "${name}" ON "${change.table}" (${cols})`);
+  }
+  async applyDropIndex(change) {
+    await this.#getClient().query(`DROP INDEX "${change.name}"`);
+  }
+  async applyAddForeignKey(change) {
+    const name = change.name ?? `fk_${change.table}_${change.on}`;
+    let sql = `ALTER TABLE "${change.table}" ADD CONSTRAINT "${name}" FOREIGN KEY ("${change.on}") REFERENCES "${change.references.table}" ("${change.references.column}")`;
+    if (change.onDelete) sql += ` ON DELETE ${this.#renderFkAction(change.onDelete)}`;
+    if (change.onUpdate) sql += ` ON UPDATE ${this.#renderFkAction(change.onUpdate)}`;
+    await this.#getClient().query(sql);
+  }
+  async applyDropForeignKey(change) {
+    await this.#getClient().query(`ALTER TABLE "${change.table}" DROP CONSTRAINT "${change.name}"`);
+  }
+  async introspect() {
+    const { OrmIntrospectionError: OrmIntrospectionError2 } = await Promise.resolve().then(() => (init_introspection(), introspection_exports));
+    const client = this.#getClient();
+    const tablesResult = await client.query(`
+			SELECT table_name FROM information_schema.tables
+			WHERE table_schema = 'public' AND table_type = 'BASE TABLE' AND table_name != $1
+		`, [TRACKER_TABLE]);
+    const schemas = [];
+    for (const tableRow of tablesResult.rows) {
+      const tableName = tableRow.table_name;
+      const colsResult = await client.query(`
+				SELECT column_name, data_type, is_nullable, column_default
+				FROM information_schema.columns
+				WHERE table_schema = 'public' AND table_name = $1
+				ORDER BY ordinal_position
+			`, [tableName]);
+      const pkResult = await client.query(`
+				SELECT kcu.column_name
+				FROM information_schema.table_constraints tc
+				JOIN information_schema.key_column_usage kcu
+					ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+				WHERE tc.table_schema = 'public' AND tc.table_name = $1 AND tc.constraint_type = 'PRIMARY KEY'
+			`, [tableName]);
+      const pkColName = pkResult.rows[0]?.column_name;
+      const uniqueResult = await client.query(`
+				SELECT kcu.column_name
+				FROM information_schema.table_constraints tc
+				JOIN information_schema.key_column_usage kcu
+					ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+				WHERE tc.table_schema = 'public' AND tc.table_name = $1 AND tc.constraint_type = 'UNIQUE'
+			`, [tableName]);
+      const uniqueCols = new Set(uniqueResult.rows.map((r) => r.column_name));
+      let pk;
+      const fields = [];
+      for (const col of colsResult.rows) {
+        const pgType = col.data_type.toLowerCase();
+        const fieldType = PG_TO_FIELD_TYPE[pgType];
+        if (!fieldType) {
+          throw new OrmIntrospectionError2({ adapter: "postgresql", table: tableName, cause: `Unsupported column type '${pgType}' on column '${col.column_name}'` });
+        }
+        if (col.column_name === pkColName) {
+          pk = { name: col.column_name, type: fieldType };
+          continue;
+        }
+        const nullable = col.is_nullable === "YES";
+        const raw = col.column_default;
+        const def = this.#parseDefault(raw);
+        fields.push({
+          name: col.column_name,
+          type: fieldType,
+          nullable,
+          ...def !== void 0 ? { default: def } : {},
+          ...uniqueCols.has(col.column_name) ? { unique: true } : {}
+        });
+      }
+      const idxResult = await client.query(`
+				SELECT indexname, indexdef
+				FROM pg_indexes
+				WHERE schemaname = 'public' AND tablename = $1
+			`, [tableName]);
+      const indexes = [];
+      for (const idx of idxResult.rows) {
+        const idxName = idx.indexname;
+        const idxDef = idx.indexdef;
+        if (idxDef.includes("PRIMARY KEY") || idxName.endsWith("_pkey")) continue;
+        const unique = idxDef.toUpperCase().includes("UNIQUE");
+        const colMatch = idxDef.match(/\(([^)]+)\)/);
+        const cols = colMatch ? colMatch[1].split(",").map((c) => c.trim().replace(/"/g, "")) : [];
+        indexes.push({ name: idxName, on: cols, unique });
+      }
+      const fkResult = await client.query(`
+				SELECT
+					tc.constraint_name,
+					kcu.column_name,
+					ccu.table_name AS foreign_table_name,
+					ccu.column_name AS foreign_column_name,
+					rc.delete_rule,
+					rc.update_rule
+				FROM information_schema.table_constraints tc
+				JOIN information_schema.key_column_usage kcu
+					ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+				JOIN information_schema.constraint_column_usage ccu
+					ON tc.constraint_name = ccu.constraint_name AND tc.table_schema = ccu.table_schema
+				JOIN information_schema.referential_constraints rc
+					ON tc.constraint_name = rc.constraint_name AND tc.table_schema = rc.constraint_schema
+				WHERE tc.table_schema = 'public' AND tc.table_name = $1 AND tc.constraint_type = 'FOREIGN KEY'
+			`, [tableName]);
+      const foreignKeys = [];
+      for (const fk of fkResult.rows) {
+        foreignKeys.push({
+          name: fk.constraint_name,
+          on: fk.column_name,
+          references: { table: fk.foreign_table_name, column: fk.foreign_column_name },
+          ...fk.delete_rule && fk.delete_rule !== "NO ACTION" ? { onDelete: this.#parseFkAction(fk.delete_rule) } : {},
+          ...fk.update_rule && fk.update_rule !== "NO ACTION" ? { onUpdate: this.#parseFkAction(fk.update_rule) } : {}
+        });
+      }
+      schemas.push({ name: tableName, pk, fields, indexes, foreignKeys });
+    }
+    return schemas;
+  }
+  #renderColumnDef(f) {
+    const pgType = FIELD_TYPE_TO_PG[f.type] ?? "text";
+    let def = `"${f.name}" ${pgType}`;
+    if (!f.nullable) def += " NOT NULL";
+    if (f.default !== void 0) def += ` DEFAULT ${this.#renderDefault(f.default)}`;
+    if (f.unique) def += " UNIQUE";
+    return def;
+  }
+  #renderDefault(val) {
+    if (val === null) return "NULL";
+    if (typeof val === "string") return `'${val.replace(/'/g, "''")}'`;
+    if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
+    return String(val);
+  }
+  #deriveIndexName(table, cols, unique) {
+    const base = `idx_${table}_${cols.join("_")}`;
+    return unique ? `${base}_unique` : base;
+  }
+  #renderFkAction(action) {
+    const map = { cascade: "CASCADE", restrict: "RESTRICT", setnull: "SET NULL", noaction: "NO ACTION" };
+    return map[action.toLowerCase()] ?? "NO ACTION";
+  }
+  #parseFkAction(rule) {
+    const map = { CASCADE: "cascade", RESTRICT: "restrict", "SET NULL": "setNull" };
+    return map[rule.toUpperCase()] ?? "noAction";
+  }
+  #parseDefault(raw) {
+    if (raw === null || raw === void 0) return void 0;
+    if (raw === "NULL" || raw === "NULL::text") return null;
+    if (raw === "true" || raw === "TRUE") return true;
+    if (raw === "false" || raw === "FALSE") return false;
+    const numMatch = raw.match(/^(-?\d+(?:\.\d+)?)$/);
+    if (numMatch) return Number(numMatch[1]);
+    const strMatch = raw.match(/^'(.*)'(?:::.*)?$/);
+    if (strMatch) return strMatch[1].replace(/''/g, "'");
+    return void 0;
+  }
+  async session(fn) {
+    if (this.#sessionStore.getStore()) return fn();
+    let client;
+    try {
+      client = await this.pool.connect();
+      await client.query("BEGIN");
+      const result = await this.#sessionStore.run(client, fn);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      if (client) {
+        try {
+          await client.query("ROLLBACK");
+        } catch {
+        }
+      }
+      if (error instanceof EquippedError) throw error;
+      throw new EquippedError("PostgreSQL session failed", { adapter: "postgresql", operation: "session" }, error);
+    } finally {
+      client?.release();
+    }
+  }
+};
+if (void 0) {
+  const { describe, test, expect, expectTypeOf, vi, beforeEach, afterEach } = void 0;
+  const testConnectionConfig = {
+    host: "localhost",
+    port: 5432,
+    username: "test",
+    password: "test",
+    database: "testdb",
+    ssl: false
+  };
+  describe("PostgresAdapter: class-via-configurable shape", () => {
+    let onSpy;
+    beforeEach(async () => {
+      const { Instance: Instance2 } = await null;
+      onSpy = vi.spyOn(Instance2, "on").mockImplementation(() => {
+      });
+    });
+    afterEach(() => {
+      onSpy.mockRestore();
+    });
+    test("PostgresAdapter.create returns instance with correct capability declarations", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.supportedFieldTypes).toEqual(["string", "number", "boolean", "null", "object", "array", "date"]);
+      expect(adapter.queryableOps).toEqual([
+        "eq",
+        "ne",
+        "gt",
+        "gte",
+        "lt",
+        "lte",
+        "in",
+        "notIn",
+        "like",
+        "exists",
+        "notExists",
+        "contains",
+        "notContains"
+      ]);
+      expect(adapter.updateOps).toEqual(["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"]);
+    });
+    test("PostgresAdapter.create validates connection config", () => {
+      expect(() => PostgresAdapter.create({ host: 123, port: "bad" })).toThrow();
+    });
+    test("pool is exposed as a readonly instance field", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.pool).toBeInstanceOf(import_pg.Pool);
+    });
+    test("schemaConfigPipe is declared as readonly with table-name shape", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.schemaConfigPipe).toBeDefined();
+    });
+    test("auto-wires Instance hooks for connect and disconnect", () => {
+      PostgresAdapter.create(testConnectionConfig);
+      expect(onSpy).toHaveBeenCalledWith("start", expect.any(Function), expect.objectContaining({ class: PostgresAdapter }));
+      expect(onSpy).toHaveBeenCalledWith("close", expect.any(Function), expect.objectContaining({ class: PostgresAdapter }));
+    });
+    test("adapter.use returns OrmUse-shaped object", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("test").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const use = adapter.use(schema, { table: "test" });
+      expect(use.findMany).toBeTypeOf("function");
+      expect(use.iterateMany).toBeTypeOf("function");
+      expect(use.findOne).toBeTypeOf("function");
+      expect(use.count).toBeTypeOf("function");
+      expect(use.createOne).toBeTypeOf("function");
+      expect(use.createMany).toBeTypeOf("function");
+      expect(use.updateMany).toBeTypeOf("function");
+      expect(use.updateOne).toBeTypeOf("function");
+      expect(use.upsertOne).toBeTypeOf("function");
+      expect(use.deleteOne).toBeTypeOf("function");
+      expect(use.deleteMany).toBeTypeOf("function");
+      expect(use.raw).toBeTypeOf("function");
+    });
+    test("type-level: capability declarations use as const", () => {
+      const _adapter = PostgresAdapter.create(testConnectionConfig);
+      expectTypeOf().toEqualTypeOf();
+      expectTypeOf().toEqualTypeOf();
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("type-level: Repo.from with PostgresAdapter enables all builder methods", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const _one = repo.on(_TestSchema).one();
+      const _all = repo.on(_TestSchema).all();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_one.create).toBeFunction();
+      expectTypeOf(_one.find).toBeFunction();
+      expectTypeOf(_one.update).toBeFunction();
+      expectTypeOf(_one.delete).toBeFunction();
+      expectTypeOf(_one.upsert).toBeFunction();
+      expectTypeOf(_all.create).toBeFunction();
+      expectTypeOf(_all.find).toBeFunction();
+      expectTypeOf(_all.count).toBeFunction();
+      expectTypeOf(_all.update).toBeFunction();
+      expectTypeOf(_all.delete).toBeFunction();
+      expectTypeOf(_ref.raw).toBeFunction();
+      expectTypeOf(repo.session).toBeFunction();
+    });
+    test("type-level: raw arg-tuple infers (command: string, params?: unknown[]) from PostgresAdapter", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.raw).parameters.toEqualTypeOf();
+    });
+    test("type-level: per-call <T> override narrows PostgresAdapter raw return type", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.raw).returns.toEqualTypeOf();
+    });
+    test("count forwards COUNT query to pool.query and returns a number", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("pg_count").pk("id", import_valleyed5.v.string(), () => "x").field("name", import_valleyed5.v.string()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedSql;
+      let capturedParams;
+      adapter.pool.query = async (sql, params) => {
+        capturedSql = sql;
+        capturedParams = params;
+        return { rows: [{ count: "4" }] };
+      };
+      const result = await adapter.count(schema, { table: "users" }, FilterGroup2.create().eq("name", "Alice"));
+      expect(capturedSql).toBe('SELECT COUNT(*) as count FROM "users" WHERE "name" = $1');
+      expect(capturedParams).toEqual(["Alice"]);
+      expect(result).toBe(4);
+    });
+    test("raw forwards (command, params) to pool.query at runtime", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_raw").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedCommand;
+      let capturedParams;
+      const mockResult = { rows: [{ id: "1" }], rowCount: 1 };
+      adapter.pool.query = async (cmd, params) => {
+        capturedCommand = cmd;
+        capturedParams = params;
+        return mockResult;
+      };
+      const result = await adapter.use(schema, { table: "users" }).raw("SELECT * FROM users WHERE id = $1", ["abc"]);
+      expect(capturedCommand).toBe("SELECT * FROM users WHERE id = $1");
+      expect(capturedParams).toEqual(["abc"]);
+      expect(result).toBe(mockResult);
+    });
+    test("raw defaults params to [] when omitted", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_raw2").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedParams;
+      adapter.pool.query = async (_cmd, params) => {
+        capturedParams = params;
+        return { rows: [] };
+      };
+      await adapter.use(schema, { table: "users" }).raw("SELECT 1");
+      expect(capturedParams).toEqual([]);
+    });
+    test("iterateMany opens a dedicated cursor client, reads in batchSize chunks, and releases on completion", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const { OrderBy } = await null;
+      const schema = Schema.from("pg_iter").pk("id", import_valleyed5.v.string(), () => "x").field("age", import_valleyed5.v.number()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedCursor;
+      const release = vi.fn();
+      const cursor = {
+        read: vi.fn().mockResolvedValueOnce([{ id: "u3", age: 40 }]).mockResolvedValueOnce([{ id: "u1", age: 30 }]).mockResolvedValueOnce([]),
+        close: vi.fn().mockResolvedValue(void 0)
+      };
+      const client = {
+        query: vi.fn((query) => {
+          capturedCursor = query;
+          return cursor;
+        }),
+        release
+      };
+      adapter.pool.connect = vi.fn(async () => client);
+      const rows = [];
+      for await (const row of adapter.use(schema, { table: "people" }).iterateMany(FilterGroup2.create().gt("age", 19), {
+        orderBy: [new OrderBy("age", "desc")],
+        offset: 1,
+        limit: 2,
+        batchSize: 1
+      })) {
+        rows.push(row);
+      }
+      expect(adapter.pool.connect).toHaveBeenCalledTimes(1);
+      expect(capturedCursor).toBeInstanceOf(import_pg_cursor.default);
+      const capturedCursorConfig = capturedCursor;
+      expect(capturedCursorConfig.text).toBe('SELECT * FROM "people" WHERE "age" > $1 ORDER BY "age" DESC LIMIT $2 OFFSET $3');
+      expect(capturedCursorConfig.values).toEqual(["19", "2", "1"]);
+      expect(cursor.read).toHaveBeenNthCalledWith(1, 1);
+      expect(cursor.read).toHaveBeenNthCalledWith(2, 1);
+      expect(cursor.read).toHaveBeenNthCalledWith(3, 1);
+      expect(cursor.close).toHaveBeenCalledTimes(1);
+      expect(release).toHaveBeenCalledTimes(1);
+      expect(rows).toEqual([{ id: "u3", age: 40 }, { id: "u1", age: 30 }]);
+    });
+    test("iterateMany closes cursor and releases dedicated client on early break", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("pg_iter_break").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const release = vi.fn();
+      const cursor = {
+        read: vi.fn().mockResolvedValueOnce([{ id: "u1" }, { id: "u2" }]),
+        close: vi.fn().mockResolvedValue(void 0)
+      };
+      adapter.pool.connect = vi.fn(async () => ({
+        query: vi.fn(() => cursor),
+        release
+      }));
+      const rows = [];
+      for await (const row of adapter.use(schema, { table: "people" }).iterateMany(FilterGroup2.create())) {
+        rows.push(row);
+        break;
+      }
+      expect(rows).toEqual([{ id: "u1" }]);
+      expect(cursor.close).toHaveBeenCalledTimes(1);
+      expect(release).toHaveBeenCalledTimes(1);
+    });
+    test("iterateMany closes cursor and releases dedicated client when the consumer throws", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("pg_iter_throw").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const release = vi.fn();
+      const cursor = {
+        read: vi.fn().mockResolvedValueOnce([{ id: "u1" }]),
+        close: vi.fn().mockResolvedValue(void 0)
+      };
+      adapter.pool.connect = vi.fn(async () => ({
+        query: vi.fn(() => cursor),
+        release
+      }));
+      const consumerError = new Error("consumer failed");
+      await expect(async () => {
+        for await (const _row of adapter.use(schema, { table: "people" }).iterateMany(FilterGroup2.create())) {
+          throw consumerError;
+        }
+      }).rejects.toThrow(consumerError);
+      expect(cursor.close).toHaveBeenCalledTimes(1);
+      expect(release).toHaveBeenCalledTimes(1);
+    });
+    test("iterateMany inside a session uses the active client and leaves release ownership to session", async () => {
+      const { Schema } = await null;
+      const { FilterGroup: FilterGroup2 } = await null;
+      const schema = Schema.from("pg_iter_session").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const events = [];
+      const release = vi.fn(() => events.push("release"));
+      const cursor = {
+        read: vi.fn().mockResolvedValueOnce([{ id: "u1" }]).mockResolvedValueOnce([]),
+        close: vi.fn(async () => events.push("cursor.close"))
+      };
+      const client = {
+        query: vi.fn((query) => {
+          if (typeof query === "string") {
+            events.push(query);
+            return { rows: [] };
+          }
+          events.push("cursor.open");
+          return cursor;
+        }),
+        release
+      };
+      adapter.pool.connect = vi.fn(async () => client);
+      const rows = [];
+      await adapter.session(async () => {
+        for await (const row of adapter.use(schema, { table: "people" }).iterateMany(FilterGroup2.create(), { batchSize: 1 })) {
+          rows.push(row);
+        }
+        events.push("session.body.done");
+      });
+      expect(adapter.pool.connect).toHaveBeenCalledTimes(1);
+      expect(rows).toEqual([{ id: "u1" }]);
+      expect(events).toEqual(["BEGIN", "cursor.open", "cursor.close", "session.body.done", "COMMIT", "release"]);
+      expect(release).toHaveBeenCalledTimes(1);
+    });
+    test("session method is exposed on the adapter", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.session).toBeDefined();
+      expect(adapter.session).toBeTypeOf("function");
+    });
+    test("declares aggregateOps with all six canonical ops", () => {
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      expect(adapter.aggregateOps).toEqual(["count", "countDistinct", "sum", "avg", "min", "max"]);
+    });
+    test("type-level: aggregateOps is a readonly tuple of all six ops", () => {
+      const _adapter = PostgresAdapter.create(testConnectionConfig);
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("aggregate method forwards spec to pool.query and returns mapped rows", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_agg").pk("id", import_valleyed5.v.string(), () => "x").field("amount", import_valleyed5.v.number()).field("region", import_valleyed5.v.string()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      let capturedSql;
+      let capturedParams;
+      adapter.pool.query = async (sql, params) => {
+        capturedSql = sql;
+        capturedParams = params;
+        return { rows: [{ total: "5" }] };
+      };
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      });
+      expect(capturedSql).toBe('SELECT COUNT(*) AS "total" FROM "orders"');
+      expect(capturedParams).toEqual([]);
+      expect(result).toEqual([{ total: 5 }]);
+    });
+    test("aggregate converts PG bigint/numeric strings to numbers for count/sum/avg", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_agg_types").pk("id", import_valleyed5.v.string(), () => "x").field("amount", import_valleyed5.v.number()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      adapter.pool.query = async () => ({
+        rows: [{ cnt: "10", revenue: "250.50", avgAmt: "25.05" }]
+      });
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [
+          { fn: "count", alias: "cnt" },
+          { fn: "sum", field: "amount", alias: "revenue" },
+          { fn: "avg", field: "amount", alias: "avgAmt" }
+        ],
+        groupBy: []
+      });
+      expect(result[0].cnt).toBe(10);
+      expect(result[0].revenue).toBe(250.5);
+      expect(result[0].avgAmt).toBe(25.05);
+    });
+    test("aggregate preserves original type for min/max", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_agg_minmax").pk("id", import_valleyed5.v.string(), () => "x").field("name", import_valleyed5.v.string()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      adapter.pool.query = async () => ({
+        rows: [{ lowest: "Alice", highest: "Zara" }]
+      });
+      const result = await adapter.aggregate(schema, { table: "users" }, {
+        aggregates: [
+          { fn: "min", field: "name", alias: "lowest" },
+          { fn: "max", field: "name", alias: "highest" }
+        ],
+        groupBy: []
+      });
+      expect(result[0].lowest).toBe("Alice");
+      expect(result[0].highest).toBe("Zara");
+    });
+    test("aggregate includes groupBy fields in result rows", async () => {
+      const { Schema } = await null;
+      const schema = Schema.from("pg_agg_group").pk("id", import_valleyed5.v.string(), () => "x").field("region", import_valleyed5.v.string()).build();
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      adapter.pool.query = async () => ({
+        rows: [
+          { cnt: "3", region: "US" },
+          { cnt: "2", region: "EU" }
+        ]
+      });
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [{ fn: "count", alias: "cnt" }],
+        groupBy: ["region"]
+      });
+      expect(result).toEqual([
+        { cnt: 3, region: "US" },
+        { cnt: 2, region: "EU" }
+      ]);
+    });
+    test("type-level: Repo.from with PostgresAdapter enables aggregate method", async () => {
+      const { Repo } = await null;
+      const { Schema } = await null;
+      const adapter = PostgresAdapter.create(testConnectionConfig);
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const _TestSchema = Schema.from("test").pk("id", import_valleyed5.v.string(), () => "x").build();
+      const _ref = repo.on(_TestSchema);
+      expectTypeOf(_ref.aggregate).toBeFunction();
+    });
+  });
+  describe("PostgresAdapter: migration methods", () => {
+    let onSpy;
+    let adapter;
+    let queries;
+    beforeEach(async () => {
+      const { Instance: Instance2 } = await null;
+      onSpy = vi.spyOn(Instance2, "on").mockImplementation(() => {
+      });
+      adapter = PostgresAdapter.create(testConnectionConfig);
+      queries = [];
+      adapter.pool.query = async (sql, params) => {
+        queries.push({ sql, params });
+        return { rows: [] };
+      };
+    });
+    afterEach(() => {
+      onSpy.mockRestore();
+    });
+    test("loadMigrations creates tracker table then selects rows", async () => {
+      ;
+      adapter.pool.query = async (sql, params) => {
+        queries.push({ sql, params });
+        if (sql.includes("SELECT id")) {
+          return { rows: [{ id: "0001", applied_at: "1700000000000" }] };
+        }
+        return { rows: [] };
+      };
+      const result = await adapter.loadMigrations();
+      expect(queries).toHaveLength(2);
+      expect(queries[0].sql).toContain("CREATE TABLE IF NOT EXISTS");
+      expect(queries[0].sql).toContain("equipped_migrations");
+      expect(queries[1].sql).toContain("SELECT id, applied_at");
+      expect(result).toEqual([{ id: "0001", appliedAt: 17e11 }]);
+    });
+    test("recordMigration inserts into tracker table", async () => {
+      await adapter.recordMigration("0001-init", 17e11);
+      expect(queries).toHaveLength(1);
+      expect(queries[0].sql).toContain("INSERT INTO");
+      expect(queries[0].sql).toContain("equipped_migrations");
+      expect(queries[0].params).toEqual(["0001-init", 17e11]);
+    });
+    test("acquireMigrationLock wraps fn with pg_advisory_lock/unlock", async () => {
+      const result = await adapter.acquireMigrationLock(async () => {
+        queries.push({ sql: "USER_FN" });
+        return 42;
+      });
+      expect(result).toBe(42);
+      expect(queries[0].sql).toContain("pg_advisory_lock");
+      expect(queries[1].sql).toBe("USER_FN");
+      expect(queries[2].sql).toContain("pg_advisory_unlock");
+    });
+    test("acquireMigrationLock unlocks even on error", async () => {
+      await expect(adapter.acquireMigrationLock(async () => {
+        throw new Error("boom");
+      })).rejects.toThrow("boom");
+      expect(queries[0].sql).toContain("pg_advisory_lock");
+      expect(queries[1].sql).toContain("pg_advisory_unlock");
+    });
+    test("applyCreateTable generates correct DDL", async () => {
+      await adapter.applyCreateTable({
+        kind: "createTable",
+        name: "users",
+        pk: { name: "id", type: "string" },
+        fields: [
+          { name: "email", type: "string", unique: true },
+          { name: "age", type: "number", nullable: true },
+          { name: "active", type: "boolean", default: true }
+        ]
+      });
+      expect(queries).toHaveLength(1);
+      const sql = queries[0].sql;
+      expect(sql).toContain('CREATE TABLE "users"');
+      expect(sql).toContain('"id" text PRIMARY KEY');
+      expect(sql).toContain('"email" text NOT NULL UNIQUE');
+      expect(sql).toContain('"age" double precision');
+      expect(sql).not.toContain('"age" double precision NOT NULL');
+      expect(sql).toContain('"active" boolean NOT NULL DEFAULT TRUE');
+    });
+    test("applyDropTable generates DROP TABLE", async () => {
+      await adapter.applyDropTable({ kind: "dropTable", name: "users" });
+      expect(queries[0].sql).toBe('DROP TABLE "users"');
+    });
+    test("applyAddField generates ALTER TABLE ADD COLUMN", async () => {
+      await adapter.applyAddField({
+        kind: "addField",
+        table: "users",
+        field: { name: "bio", type: "string", nullable: true, default: "none" }
+      });
+      expect(queries[0].sql).toContain('ALTER TABLE "users" ADD COLUMN');
+      expect(queries[0].sql).toContain('"bio" text');
+      expect(queries[0].sql).not.toContain("NOT NULL");
+      expect(queries[0].sql).toContain("DEFAULT 'none'");
+    });
+    test("applyDropField generates ALTER TABLE DROP COLUMN", async () => {
+      await adapter.applyDropField({ kind: "dropField", table: "users", name: "bio" });
+      expect(queries[0].sql).toBe('ALTER TABLE "users" DROP COLUMN "bio"');
+    });
+    test("applyModifyField generates ALTER COLUMN statements for type, nullable, default", async () => {
+      await adapter.applyModifyField({
+        kind: "modifyField",
+        table: "users",
+        name: "age",
+        to: { name: "age", type: "string", nullable: true, default: null }
+      });
+      expect(queries[0].sql).toContain('ALTER COLUMN "age" TYPE text');
+      expect(queries[1].sql).toContain("DROP NOT NULL");
+      expect(queries[2].sql).toContain("SET DEFAULT NULL");
+    });
+    test("applyModifyField renames column when to.name differs", async () => {
+      await adapter.applyModifyField({
+        kind: "modifyField",
+        table: "users",
+        name: "age",
+        to: { name: "years", type: "number" }
+      });
+      const renameSql = queries.find((q) => q.sql.includes("RENAME COLUMN"));
+      expect(renameSql).toBeDefined();
+      expect(renameSql.sql).toContain('RENAME COLUMN "age" TO "years"');
+    });
+    test("applyRenameTable generates ALTER TABLE RENAME", async () => {
+      await adapter.applyRenameTable({ kind: "renameTable", from: "users", to: "accounts" });
+      expect(queries[0].sql).toBe('ALTER TABLE "users" RENAME TO "accounts"');
+    });
+    test("applyRenameField generates ALTER TABLE RENAME COLUMN", async () => {
+      await adapter.applyRenameField({ kind: "renameField", table: "users", from: "name", to: "fullName" });
+      expect(queries[0].sql).toBe('ALTER TABLE "users" RENAME COLUMN "name" TO "fullName"');
+    });
+    test("applyAddIndex generates CREATE INDEX with auto-derived name", async () => {
+      await adapter.applyAddIndex({ kind: "addIndex", table: "users", on: ["email"] });
+      expect(queries[0].sql).toBe('CREATE INDEX "idx_users_email" ON "users" ("email")');
+    });
+    test("applyAddIndex generates CREATE UNIQUE INDEX with explicit name", async () => {
+      await adapter.applyAddIndex({ kind: "addIndex", table: "users", on: ["email"], unique: true, name: "my_idx" });
+      expect(queries[0].sql).toBe('CREATE UNIQUE INDEX "my_idx" ON "users" ("email")');
+    });
+    test("applyAddIndex auto-derives unique suffix when unique and no name", async () => {
+      await adapter.applyAddIndex({ kind: "addIndex", table: "posts", on: ["author", "title"], unique: true });
+      expect(queries[0].sql).toBe('CREATE UNIQUE INDEX "idx_posts_author_title_unique" ON "posts" ("author", "title")');
+    });
+    test("applyDropIndex generates DROP INDEX", async () => {
+      await adapter.applyDropIndex({ kind: "dropIndex", name: "idx_users_email" });
+      expect(queries[0].sql).toBe('DROP INDEX "idx_users_email"');
+    });
+    test("applyAddForeignKey generates ALTER TABLE ADD CONSTRAINT with auto-derived name", async () => {
+      await adapter.applyAddForeignKey({
+        kind: "addForeignKey",
+        table: "posts",
+        on: "authorId",
+        references: { table: "users", column: "id" },
+        onDelete: "cascade",
+        onUpdate: "setNull"
+      });
+      const sql = queries[0].sql;
+      expect(sql).toContain('ALTER TABLE "posts" ADD CONSTRAINT "fk_posts_authorId"');
+      expect(sql).toContain('FOREIGN KEY ("authorId") REFERENCES "users" ("id")');
+      expect(sql).toContain("ON DELETE CASCADE");
+      expect(sql).toContain("ON UPDATE SET NULL");
+    });
+    test("applyAddForeignKey uses explicit name when provided", async () => {
+      await adapter.applyAddForeignKey({
+        kind: "addForeignKey",
+        table: "posts",
+        on: "authorId",
+        references: { table: "users", column: "id" },
+        name: "custom_fk"
+      });
+      expect(queries[0].sql).toContain('ADD CONSTRAINT "custom_fk"');
+    });
+    test("applyDropForeignKey generates ALTER TABLE DROP CONSTRAINT", async () => {
+      await adapter.applyDropForeignKey({ kind: "dropForeignKey", table: "posts", name: "fk_posts_authorId" });
+      expect(queries[0].sql).toBe('ALTER TABLE "posts" DROP CONSTRAINT "fk_posts_authorId"');
+    });
+    test("introspect queries information_schema and builds DiscoveredSchema[]", async () => {
+      ;
+      adapter.pool.query = async (sql, params) => {
+        queries.push({ sql, params });
+        if (sql.includes("information_schema.tables")) {
+          return { rows: [{ table_name: "users" }] };
+        }
+        if (sql.includes("information_schema.columns")) {
+          return {
+            rows: [
+              { column_name: "id", data_type: "text", is_nullable: "NO", column_default: null },
+              { column_name: "email", data_type: "character varying", is_nullable: "NO", column_default: null },
+              { column_name: "age", data_type: "integer", is_nullable: "YES", column_default: "25" }
+            ]
+          };
+        }
+        if (sql.includes("PRIMARY KEY")) {
+          return { rows: [{ column_name: "id" }] };
+        }
+        if (sql.includes("constraint_type = 'UNIQUE'")) {
+          return { rows: [{ column_name: "email" }] };
+        }
+        if (sql.includes("pg_indexes")) {
+          return { rows: [{ indexname: "users_email_idx", indexdef: "CREATE UNIQUE INDEX users_email_idx ON public.users USING btree (email)" }] };
+        }
+        if (sql.includes("constraint_type = 'FOREIGN KEY'")) {
+          return { rows: [] };
+        }
+        return { rows: [] };
+      };
+      const schemas = await adapter.introspect();
+      expect(schemas).toHaveLength(1);
+      const s = schemas[0];
+      expect(s.name).toBe("users");
+      expect(s.pk).toEqual({ name: "id", type: "string" });
+      expect(s.fields).toEqual([
+        { name: "email", type: "string", nullable: false, unique: true },
+        { name: "age", type: "number", nullable: true, default: 25 }
+      ]);
+      expect(s.indexes).toEqual([{ name: "users_email_idx", on: ["email"], unique: true }]);
+      expect(s.foreignKeys).toEqual([]);
+    });
+    test("introspect throws OrmIntrospectionError on unsupported PG type", async () => {
+      const { OrmIntrospectionError: OrmIntrospectionError2 } = await null;
+      adapter.pool.query = async (sql) => {
+        if (sql.includes("information_schema.tables")) {
+          return { rows: [{ table_name: "files" }] };
+        }
+        if (sql.includes("information_schema.columns")) {
+          return {
+            rows: [
+              { column_name: "id", data_type: "text", is_nullable: "NO", column_default: null },
+              { column_name: "data", data_type: "bytea", is_nullable: "YES", column_default: null }
+            ]
+          };
+        }
+        if (sql.includes("PRIMARY KEY")) {
+          return { rows: [{ column_name: "id" }] };
+        }
+        if (sql.includes("constraint_type = 'UNIQUE'")) {
+          return { rows: [] };
+        }
+        return { rows: [] };
+      };
+      await expect(adapter.introspect()).rejects.toThrow(OrmIntrospectionError2);
+      try {
+        await adapter.introspect();
+      } catch (err) {
+        expect(err.adapter).toBe("postgresql");
+        expect(err.table).toBe("files");
+        expect(err.cause).toContain("bytea");
+      }
+    });
+    test("introspect parses foreign keys with cascade actions", async () => {
+      ;
+      adapter.pool.query = async (sql) => {
+        if (sql.includes("information_schema.tables")) {
+          return { rows: [{ table_name: "posts" }] };
+        }
+        if (sql.includes("information_schema.columns")) {
+          return {
+            rows: [
+              { column_name: "id", data_type: "text", is_nullable: "NO", column_default: null },
+              { column_name: "author_id", data_type: "text", is_nullable: "NO", column_default: null }
+            ]
+          };
+        }
+        if (sql.includes("PRIMARY KEY")) {
+          return { rows: [{ column_name: "id" }] };
+        }
+        if (sql.includes("constraint_type = 'UNIQUE'")) {
+          return { rows: [] };
+        }
+        if (sql.includes("pg_indexes")) {
+          return { rows: [] };
+        }
+        if (sql.includes("constraint_type = 'FOREIGN KEY'")) {
+          return {
+            rows: [{
+              constraint_name: "fk_posts_author_id",
+              column_name: "author_id",
+              foreign_table_name: "users",
+              foreign_column_name: "id",
+              delete_rule: "CASCADE",
+              update_rule: "SET NULL"
+            }]
+          };
+        }
+        return { rows: [] };
+      };
+      const schemas = await adapter.introspect();
+      expect(schemas[0].foreignKeys).toEqual([{
+        name: "fk_posts_author_id",
+        on: "author_id",
+        references: { table: "users", column: "id" },
+        onDelete: "cascade",
+        onUpdate: "setNull"
+      }]);
+    });
+    test("introspect excludes tracker table from results", async () => {
+      ;
+      adapter.pool.query = async (sql, params) => {
+        if (sql.includes("information_schema.tables")) {
+          expect(params).toContain("equipped_migrations");
+          return { rows: [] };
+        }
+        return { rows: [] };
+      };
+      const schemas = await adapter.introspect();
+      expect(schemas).toEqual([]);
+    });
+    test("type-level: PostgresAdapter declares all migration methods", () => {
+      expectTypeOf(adapter.loadMigrations).toBeFunction();
+      expectTypeOf(adapter.recordMigration).toBeFunction();
+      expectTypeOf(adapter.acquireMigrationLock).toBeFunction();
+      expectTypeOf(adapter.applyCreateTable).toBeFunction();
+      expectTypeOf(adapter.applyDropTable).toBeFunction();
+      expectTypeOf(adapter.applyAddField).toBeFunction();
+      expectTypeOf(adapter.applyDropField).toBeFunction();
+      expectTypeOf(adapter.applyModifyField).toBeFunction();
+      expectTypeOf(adapter.applyRenameTable).toBeFunction();
+      expectTypeOf(adapter.applyRenameField).toBeFunction();
+      expectTypeOf(adapter.applyAddIndex).toBeFunction();
+      expectTypeOf(adapter.applyDropIndex).toBeFunction();
+      expectTypeOf(adapter.applyAddForeignKey).toBeFunction();
+      expectTypeOf(adapter.applyDropForeignKey).toBeFunction();
+      expectTypeOf(adapter.introspect).toBeFunction();
+    });
+    test("type-level: Migrator.from rejects withoutLock for PostgresAdapter", async () => {
+      const { Repo } = await null;
+      const { Migrator } = await null;
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      const step = Migrator.from(repo, adapter).migrations([]);
+      expectTypeOf(step).toHaveProperty("build");
+      expectTypeOf(step).not.toHaveProperty("withoutLock");
+    });
+    test("applyCreateTable maps all field types to correct PG types", async () => {
+      await adapter.applyCreateTable({
+        kind: "createTable",
+        name: "all_types",
+        pk: { name: "id", type: "string" },
+        fields: [
+          { name: "f_num", type: "number" },
+          { name: "f_bool", type: "boolean" },
+          { name: "f_date", type: "date" },
+          { name: "f_null", type: "null" },
+          { name: "f_obj", type: "object" },
+          { name: "f_arr", type: "array" }
+        ]
+      });
+      const sql = queries[0].sql;
+      expect(sql).toContain('"f_num" double precision NOT NULL');
+      expect(sql).toContain('"f_bool" boolean NOT NULL');
+      expect(sql).toContain('"f_date" timestamptz NOT NULL');
+      expect(sql).toContain('"f_null" text NOT NULL');
+      expect(sql).toContain('"f_obj" jsonb NOT NULL');
+      expect(sql).toContain('"f_arr" jsonb NOT NULL');
+    });
+    test("applyModifyField sets NOT NULL when nullable is falsy", async () => {
+      await adapter.applyModifyField({
+        kind: "modifyField",
+        table: "users",
+        name: "email",
+        to: { name: "email", type: "string" }
+      });
+      expect(queries[1].sql).toContain("SET NOT NULL");
+    });
+    test("applyModifyField drops default when to.default is undefined", async () => {
+      await adapter.applyModifyField({
+        kind: "modifyField",
+        table: "users",
+        name: "age",
+        to: { name: "age", type: "number" }
+      });
+      expect(queries[2].sql).toContain("DROP DEFAULT");
+    });
+    test("applyAddField with string default escapes single quotes", async () => {
+      await adapter.applyAddField({
+        kind: "addField",
+        table: "users",
+        field: { name: "bio", type: "string", default: "it's" }
+      });
+      expect(queries[0].sql).toContain("DEFAULT 'it''s'");
+    });
+    test("end-to-end: Migrator.from(repo, adapter) wires up correctly", async () => {
+      const { Repo } = await null;
+      const { Migrator } = await null;
+      const { Schema } = await null;
+      Schema.from("users").pk("id", import_valleyed5.v.string(), () => "x").field("email", import_valleyed5.v.string()).build();
+      const repo = Repo.from(adapter).resolve(() => ({ table: "test" })).build();
+      let loadCalls = 0;
+      const mockClient = {
+        query: async (sql, _params) => {
+          if (sql.includes("pg_advisory_lock") || sql.includes("pg_advisory_unlock")) return { rows: [] };
+          if (sql.includes("CREATE TABLE IF NOT EXISTS")) return { rows: [] };
+          if (sql.includes("SELECT id, applied_at")) {
+            loadCalls++;
+            return { rows: [] };
+          }
+          if (sql.includes("INSERT INTO")) return { rows: [] };
+          if (sql.includes("CREATE TABLE")) return { rows: [] };
+          if (sql === "BEGIN" || sql === "COMMIT" || sql === "ROLLBACK") return { rows: [] };
+          return { rows: [] };
+        },
+        release: () => {
+        }
+      };
+      adapter.pool.query = mockClient.query;
+      adapter.pool.connect = async () => mockClient;
+      const migrator = Migrator.from(repo, adapter).migrations([
+        { id: "0001", changes: [{ kind: "createTable", name: "users", pk: { name: "id", type: "string" }, fields: [{ name: "email", type: "string" }] }] }
+      ]).build();
+      const result = await migrator.up();
+      expect(result.ran).toEqual(["0001"]);
+      expect(loadCalls).toBe(1);
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PostgresAdapter
+});
+//# sourceMappingURL=index.cjs.map