equipped 5.2.9 → 5.3.0-alpha.0

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

@@ -0,0 +1,3518 @@
+"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 __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/orm/adapters/json/index.ts
+var json_exports = {};
+__export(json_exports, {
+  JsonAdapter: () => JsonAdapter
+});
+module.exports = __toCommonJS(json_exports);
+var import_promises = require("fs/promises");
+var import_valleyed6 = require("valleyed");
+
+// src/utilities/configurable.ts
+var import_valleyed = require("valleyed");
+function configurable(pipeFn, base) {
+  const pipe = pipeFn();
+  import_valleyed.v.compile(pipe);
+  class Configurable extends base {
+    constructor(config, ...baseArgs) {
+      super(...baseArgs);
+      this.config = config;
+    }
+    static create(input, ...args) {
+      const r = import_valleyed.v.validate(pipe, input);
+      if (!r.valid) throw r.error;
+      return new this(r.value, ...args);
+    }
+  }
+  return Configurable;
+}
+if (void 0) {
+  const { describe, test, expect, expectTypeOf } = void 0;
+  const { v: v7 } = null;
+  const testPipe = () => v7.object({
+    host: v7.string(),
+    port: v7.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/errors/equippedError.ts
+var EquippedError = class extends Error {
+  constructor(message, context, cause) {
+    super(message, { cause });
+    this.message = message;
+    this.context = context;
+    this.cause = cause;
+  }
+};
+
+// src/instance/index.ts
+var import_pino = __toESM(require("pino"), 1);
+var import_ulid = require("ulid");
+var import_valleyed3 = require("valleyed");
+
+// 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}`));
+        }
+      })
+    );
+}
+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_valleyed2 = require("valleyed");
+var instanceSettingsPipe = () => import_valleyed2.v.object({
+  app: import_valleyed2.v.object({
+    name: import_valleyed2.v.string()
+  }),
+  log: import_valleyed2.v.defaults(
+    import_valleyed2.v.object({
+      level: import_valleyed2.v.defaults(import_valleyed2.v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+    }),
+    {}
+  ),
+  utils: import_valleyed2.v.defaults(
+    import_valleyed2.v.object({
+      hashSaltRounds: import_valleyed2.v.defaults(import_valleyed2.v.number(), 10),
+      paginationDefaultLimit: import_valleyed2.v.defaults(import_valleyed2.v.number(), 100),
+      maxFileUploadSizeInMb: import_valleyed2.v.defaults(import_valleyed2.v.number(), 500)
+    }),
+    {}
+  )
+});
+
+// src/instance/index.ts
+var 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_valleyed3.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_valleyed3.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/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: v7 } = null;
+  const { Schema } = null;
+  const UserSchema = Schema.from("users").pk("id", v7.string(), () => "u1").field("email", v7.string()).field("age", v7.number()).field("name", v7.string()).field("tags", v7.array(v7.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/orm-adapter.ts
+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: v7 } = 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 = v7.object({ table: v7.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 = v7.object({ table: v7.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 = v7.object({ table: v7.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 = v7.object({ table: v7.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 = v7.object({ table: v7.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 = v7.object({ table: v7.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", v7.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 = v7.object({ table: v7.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", v7.string(), () => "x").field("name", v7.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 = v7.object({ table: v7.string() });
+        supportedFieldTypes = ["string"];
+        async findMany() {
+          findManyCalls += 1;
+          return [{ id: "found" }];
+        }
+      }
+      const TestSchema = Schema.from("iter_no_fallback").pk("id", v7.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 = v7.object({ table: v7.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", v7.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 = v7.object({ table: v7.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 = v7.object({ table: v7.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/in-memory/index.ts
+var import_node_async_hooks = require("async_hooks");
+var import_valleyed5 = require("valleyed");
+
+// 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";
+};
+if (void 0) {
+  const { describe, test, expect, expectTypeOf } = void 0;
+  const { v: v7 } = null;
+  const { Schema } = null;
+  const TestSchema = Schema.from("test").pk("id", v7.string(), () => "x").field("name", v7.string()).field("age", v7.number()).field("score", v7.optional(v7.number())).field("tags", v7.array(v7.string())).field("meta", v7.object({ a: v7.number() })).field("createdAt", v7.number(), { onCreate: () => 1e3 }).field("updatedAt", v7.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 = v7.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 = v7.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 = v7.object({});
+        supportedFieldTypes = ["string", "number"];
+        updateOps = ["set", "inc", "mul", "min", "max", "unset", "push", "pull", "patch"];
+      }
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+}
+
+// src/orm/adapters/in-memory/index.ts
+var inMemoryConnectionPipe = () => import_valleyed5.v.object({});
+function clone(value) {
+  return structuredClone(value);
+}
+var replaceMap = (target, source) => {
+  target.clear();
+  for (const [k, val] of source.entries()) target.set(k, val);
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function containsSubset(source, needle) {
+  if (Array.isArray(source)) {
+    const wanted = Array.isArray(needle) ? needle : [needle];
+    return wanted.every((item) => source.some((existing) => import_valleyed5.differ.equal(existing, item)));
+  }
+  if (isPlainObject(source) && isPlainObject(needle)) {
+    return Object.entries(needle).every(([k, v7]) => containsSubset(source[k], v7));
+  }
+  return import_valleyed5.differ.equal(source, needle);
+}
+function compareValues(a, b) {
+  if (a === b) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : 1;
+  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : 1;
+  if (typeof a === "boolean" && typeof b === "boolean") return a === false ? -1 : 1;
+  const sa = JSON.stringify(a);
+  const sb = JSON.stringify(b);
+  if (sa === sb) return 0;
+  return sa < sb ? -1 : 1;
+}
+function resolveConfigName(_, config) {
+  return `${config.prefix ?? ""}${config.table}`;
+}
+function evaluateFilter(doc, filter) {
+  const fieldValue = doc[filter.field];
+  const value = filter.value;
+  switch (filter.op) {
+    case "eq":
+      return import_valleyed5.differ.equal(fieldValue, value);
+    case "ne":
+      return !import_valleyed5.differ.equal(fieldValue, value);
+    case "gt":
+      return compareValues(fieldValue, value) > 0;
+    case "gte":
+      return compareValues(fieldValue, value) >= 0;
+    case "lt":
+      return compareValues(fieldValue, value) < 0;
+    case "lte":
+      return compareValues(fieldValue, value) <= 0;
+    case "in": {
+      if (!Array.isArray(value)) return false;
+      return value.some((v7) => import_valleyed5.differ.equal(fieldValue, v7));
+    }
+    case "notIn": {
+      if (!Array.isArray(value)) return true;
+      return !value.some((v7) => import_valleyed5.differ.equal(fieldValue, v7));
+    }
+    case "like":
+      return String(fieldValue ?? "").toLowerCase().includes(String(value ?? "").toLowerCase());
+    case "exists":
+      return fieldValue != null;
+    case "notExists":
+      return fieldValue == null;
+    case "contains":
+      return containsSubset(fieldValue, value);
+    case "notContains":
+      return !containsSubset(fieldValue, value);
+    default:
+      return false;
+  }
+}
+function evaluateChild(doc, child) {
+  if (child instanceof Filter) return evaluateFilter(doc, child);
+  if (child instanceof FilterGroup) {
+    if (child.op === "and") return child.children.every((c) => evaluateChild(doc, c));
+    if (child.op === "or") return child.children.some((c) => evaluateChild(doc, c));
+  }
+  return true;
+}
+function matchesFilter(doc, group) {
+  for (const clause of group.children) {
+    if (!evaluateChild(doc, clause)) return false;
+  }
+  return true;
+}
+function applyOptions(rows, options) {
+  let results = rows;
+  if (options?.orderBy?.length) {
+    results = [...results].sort((a, b) => {
+      for (const ord of options.orderBy ?? []) {
+        const cmp = compareValues(a[ord.field], b[ord.field]);
+        if (cmp !== 0) return ord.direction === "asc" ? cmp : -cmp;
+      }
+      return 0;
+    });
+  }
+  if (options?.offset != null) {
+    results = results.slice(Math.max(0, options.offset));
+  }
+  if (options?.limit != null) {
+    results = results.slice(0, options.limit);
+  }
+  if (options?.select?.length) {
+    const fields = new Set(options.select);
+    results = results.map((row) => {
+      const out = {};
+      for (const key of fields) out[key] = row[key];
+      return out;
+    });
+  }
+  return results;
+}
+function applyUpdateOp(current, key, value) {
+  if (value instanceof IncOp) {
+    const base = Number(current[key] ?? 0);
+    current[key] = base + value.value;
+    return;
+  }
+  if (value instanceof MulOp) {
+    const base = Number(current[key] ?? 0);
+    current[key] = base * value.value;
+    return;
+  }
+  if (value instanceof MinOp) {
+    const base = current[key];
+    current[key] = base == null || compareValues(value.value, base) < 0 ? value.value : base;
+    return;
+  }
+  if (value instanceof MaxOp) {
+    const base = current[key];
+    current[key] = base == null || compareValues(value.value, base) > 0 ? value.value : base;
+    return;
+  }
+  if (value instanceof UnsetOp) {
+    current[key] = null;
+    return;
+  }
+  if (value instanceof PushOp) {
+    const arr = Array.isArray(current[key]) ? [...current[key]] : [];
+    arr.push(clone(value.value));
+    current[key] = arr;
+    return;
+  }
+  if (value instanceof PullOp) {
+    const arr = Array.isArray(current[key]) ? current[key] : [];
+    current[key] = arr.filter((entry) => !import_valleyed5.differ.equal(entry, value.value));
+    return;
+  }
+  if (value instanceof PatchOp) {
+    const target = isPlainObject(current[key]) ? clone(current[key]) : {};
+    if (isPlainObject(value.value)) {
+      for (const [k, v7] of Object.entries(value.value)) {
+        target[k] = clone(v7);
+      }
+    }
+    current[key] = target;
+    return;
+  }
+  current[key] = clone(value);
+}
+function applyUpdateData(doc, data) {
+  const updated = clone(doc);
+  for (const [key, value] of Object.entries(data)) {
+    applyUpdateOp(updated, key, value);
+  }
+  return updated;
+}
+function applyOps(doc, ops) {
+  const updated = clone(doc);
+  for (const op of ops) {
+    if (op instanceof SetOp) {
+      for (const [key, value] of Object.entries(op.values)) {
+        updated[key] = clone(value);
+      }
+    } else {
+      applyUpdateOp(updated, op.field, op);
+    }
+  }
+  return updated;
+}
+var sessionActiveStore = new import_node_async_hooks.AsyncLocalStorage();
+var InMemoryAdapter = class extends configurable(inMemoryConnectionPipe, OrmAdapter) {
+  schemaConfigPipe = import_valleyed5.v.object({ 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"];
+  stores = /* @__PURE__ */ new Map();
+  migrations = /* @__PURE__ */ new Map();
+  indexes = /* @__PURE__ */ new Map();
+  tables = /* @__PURE__ */ new Map();
+  foreignKeys = /* @__PURE__ */ new Map();
+  #migrationLock = Promise.resolve();
+  constructor(config) {
+    super(config);
+  }
+  #getStore(name) {
+    if (!this.stores.has(name)) this.stores.set(name, /* @__PURE__ */ new Map());
+    return this.stores.get(name);
+  }
+  #resolveStore(schema, config) {
+    return this.#getStore(resolveConfigName(schema, config));
+  }
+  #snapshot() {
+    const stores = /* @__PURE__ */ new Map();
+    for (const [name, store] of this.stores.entries()) {
+      const storeCopy = /* @__PURE__ */ new Map();
+      for (const [id, doc] of store.entries()) {
+        storeCopy.set(id, clone(doc));
+      }
+      stores.set(name, storeCopy);
+    }
+    const migrations = new Map(this.migrations);
+    const indexes = new Map(this.indexes);
+    const tables = /* @__PURE__ */ new Map();
+    for (const [name, meta] of this.tables.entries()) {
+      tables.set(name, { pk: { ...meta.pk }, fields: new Map(meta.fields) });
+    }
+    const foreignKeys = new Map(this.foreignKeys);
+    return { stores, migrations, indexes, tables, foreignKeys };
+  }
+  #restore(snap) {
+    replaceMap(this.stores, snap.stores);
+    replaceMap(this.migrations, snap.migrations);
+    replaceMap(this.indexes, snap.indexes);
+    replaceMap(this.tables, snap.tables);
+    replaceMap(this.foreignKeys, snap.foreignKeys);
+  }
+  async findByPk(schema, config, pk) {
+    const store = this.#resolveStore(schema, config);
+    const doc = store.get(String(pk));
+    return doc ? clone(doc) : null;
+  }
+  async createMany(schema, config, data) {
+    const pk = schema.pkField.name;
+    const store = this.#resolveStore(schema, config);
+    return data.map((d) => {
+      const row = clone(d);
+      store.set(String(row[pk]), row);
+      return clone(row);
+    });
+  }
+  async deleteByPk(schema, config, pk) {
+    const store = this.#resolveStore(schema, config);
+    const pkStr = String(pk);
+    const doc = store.get(pkStr);
+    if (!doc) return null;
+    store.delete(pkStr);
+    return clone(doc);
+  }
+  async updateByPk(schema, config, pk, ops) {
+    const store = this.#resolveStore(schema, config);
+    const pkStr = String(pk);
+    const doc = store.get(pkStr);
+    if (!doc) return null;
+    const updated = applyOps(doc, ops);
+    store.set(pkStr, updated);
+    return clone(updated);
+  }
+  async findMany(schema, config, group, options) {
+    const store = this.#resolveStore(schema, config);
+    const rows = [...store.values()].filter((doc) => matchesFilter(doc, group)).map((doc) => clone(doc));
+    return applyOptions(rows, options);
+  }
+  async count(schema, config, group) {
+    const store = this.#resolveStore(schema, config);
+    return [...store.values()].filter((doc) => matchesFilter(doc, group)).length;
+  }
+  async *iterateMany(schema, config, group, options) {
+    const store = this.#resolveStore(schema, config);
+    const rows = applyOptions([...store.values()].filter((doc) => matchesFilter(doc, group)).map((doc) => clone(doc)), options);
+    const batchSize = typeof options?.batchSize === "number" && Number.isSafeInteger(options.batchSize) && options.batchSize > 0 ? options.batchSize : 1;
+    for (let start = 0; start < rows.length; start += batchSize) {
+      for (const row of rows.slice(start, start + batchSize)) {
+        yield row;
+      }
+    }
+  }
+  async updateMany(schema, config, group, data) {
+    const store = this.#resolveStore(schema, config);
+    const ids = [...store.entries()].filter(([, doc]) => matchesFilter(doc, group)).map(([id]) => id);
+    const updated = [];
+    for (const id of ids) {
+      const current = store.get(id);
+      if (!current) continue;
+      const next = applyUpdateData(current, data);
+      store.set(id, next);
+      updated.push(clone(next));
+    }
+    return updated;
+  }
+  async deleteMany(schema, config, filter) {
+    const store = this.#resolveStore(schema, config);
+    const pk = schema.pkField.name;
+    const rows = [...store.values()].filter((doc) => matchesFilter(doc, filter)).map((doc) => clone(doc));
+    for (const row of rows) store.delete(String(row[pk]));
+    return rows;
+  }
+  async upsertOne(schema, config, filter, create, ops) {
+    const store = this.#resolveStore(schema, config);
+    const pk = schema.pkField.name;
+    const rows = [...store.values()].filter((doc) => matchesFilter(doc, filter));
+    const current = rows[0];
+    if (current) {
+      const next = ops.length > 0 ? applyOps(current, ops) : clone(current);
+      store.set(String(next[pk]), next);
+      return clone(next);
+    }
+    const base = clone(create);
+    const result = ops.length > 0 ? applyOps(base, ops) : base;
+    store.set(String(result[pk]), result);
+    return clone(result);
+  }
+  async aggregate(schema, config, spec) {
+    const store = this.#resolveStore(schema, config);
+    let rows = [...store.values()];
+    if (spec.where) {
+      const where = spec.where;
+      rows = rows.filter((doc) => matchesFilter(doc, where));
+    }
+    const groups = /* @__PURE__ */ new Map();
+    if (spec.groupBy.length > 0) {
+      for (const row of rows) {
+        const key = JSON.stringify(spec.groupBy.map((f) => row[f]));
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(row);
+      }
+    } else {
+      groups.set("__all__", rows);
+    }
+    const results = [];
+    for (const [, groupRows] of groups) {
+      const result = {};
+      if (spec.groupBy.length > 0) {
+        for (const field of spec.groupBy) {
+          result[field] = groupRows[0][field];
+        }
+      }
+      for (const agg of spec.aggregates) {
+        switch (agg.fn) {
+          case "count":
+            result[agg.alias] = groupRows.length;
+            break;
+          case "countDistinct": {
+            const vals = new Set(groupRows.map((r) => JSON.stringify(r[agg.field])));
+            result[agg.alias] = vals.size;
+            break;
+          }
+          case "sum":
+            result[agg.alias] = groupRows.reduce((acc, r) => acc + Number(r[agg.field] ?? 0), 0);
+            break;
+          case "avg": {
+            const sum = groupRows.reduce((acc, r) => acc + Number(r[agg.field] ?? 0), 0);
+            result[agg.alias] = groupRows.length > 0 ? sum / groupRows.length : 0;
+            break;
+          }
+          case "min": {
+            let minVal = null;
+            for (const r of groupRows) {
+              const val = r[agg.field];
+              if (val != null && (minVal === null || compareValues(val, minVal) < 0)) minVal = val;
+            }
+            result[agg.alias] = minVal;
+            break;
+          }
+          case "max": {
+            let maxVal = null;
+            for (const r of groupRows) {
+              const val = r[agg.field];
+              if (val != null && (maxVal === null || compareValues(val, maxVal) > 0)) maxVal = val;
+            }
+            result[agg.alias] = maxVal;
+            break;
+          }
+        }
+      }
+      results.push(result);
+    }
+    if (spec.having) {
+      const having = spec.having;
+      return results.filter((r) => matchesFilter(r, having));
+    }
+    return results;
+  }
+  async loadMigrations() {
+    return [...this.migrations.values()].map((m) => ({ id: m.id, appliedAt: m.appliedAt }));
+  }
+  async recordMigration(id, appliedAt) {
+    this.migrations.set(id, { id, appliedAt });
+  }
+  async applyCreateTable(change) {
+    const fields = /* @__PURE__ */ new Map();
+    for (const f of change.fields) {
+      fields.set(f.name, { ...f });
+    }
+    this.tables.set(change.name, { pk: { name: change.pk.name, type: change.pk.type }, fields });
+  }
+  async applyDropTable(change) {
+    this.tables.delete(change.name);
+  }
+  async applyAddField(change) {
+    const table = this.tables.get(change.table);
+    if (table) {
+      table.fields.set(change.field.name, { ...change.field });
+    }
+  }
+  async applyDropField(change) {
+    const table = this.tables.get(change.table);
+    if (table) {
+      table.fields.delete(change.name);
+    }
+  }
+  async applyModifyField(change) {
+    const table = this.tables.get(change.table);
+    if (table) {
+      table.fields.delete(change.name);
+      table.fields.set(change.to.name, { ...change.to });
+    }
+  }
+  async applyRenameTable(change) {
+    const table = this.tables.get(change.from);
+    if (table) {
+      this.tables.delete(change.from);
+      this.tables.set(change.to, table);
+    }
+  }
+  async applyRenameField(change) {
+    const table = this.tables.get(change.table);
+    if (table) {
+      const field = table.fields.get(change.from);
+      if (field) {
+        table.fields.delete(change.from);
+        table.fields.set(change.to, { ...field, name: change.to });
+      }
+    }
+  }
+  async applyAddIndex(change) {
+    const indexName = change.name ?? `${change.table}_${change.on.join("_")}_idx`;
+    this.indexes.set(indexName, { table: change.table, on: change.on, unique: change.unique ?? false });
+  }
+  async applyDropIndex(change) {
+    this.indexes.delete(change.name);
+  }
+  async applyAddForeignKey(change) {
+    const fkName = change.name ?? `${change.table}_${change.on}_fk`;
+    this.foreignKeys.set(fkName, {
+      table: change.table,
+      on: change.on,
+      references: { table: change.references.table, column: change.references.column },
+      onDelete: change.onDelete,
+      onUpdate: change.onUpdate
+    });
+  }
+  async applyDropForeignKey(change) {
+    this.foreignKeys.delete(change.name);
+  }
+  async introspect() {
+    const schemas = [];
+    for (const [name, meta] of this.tables.entries()) {
+      const fields = [...meta.fields.values()].map((f) => ({
+        name: f.name,
+        type: f.type,
+        nullable: f.nullable ?? false,
+        ...f.default !== void 0 ? { default: f.default } : {},
+        ...f.unique ? { unique: true } : {}
+      }));
+      const indexes = [...this.indexes.entries()].filter(([, idx]) => idx.table === name).map(([idxName, idx]) => ({ name: idxName, on: idx.on, unique: idx.unique }));
+      const foreignKeys = [...this.foreignKeys.entries()].filter(([, fk]) => fk.table === name).map(([fkName, fk]) => ({
+        name: fkName,
+        on: fk.on,
+        references: { table: fk.references.table, column: fk.references.column },
+        ...fk.onDelete ? { onDelete: fk.onDelete } : {},
+        ...fk.onUpdate ? { onUpdate: fk.onUpdate } : {}
+      }));
+      schemas.push({
+        name,
+        pk: { name: meta.pk.name, type: meta.pk.type },
+        fields,
+        indexes,
+        foreignKeys
+      });
+    }
+    return schemas;
+  }
+  async acquireMigrationLock(fn) {
+    let release;
+    const next = new Promise((r) => {
+      release = r;
+    });
+    const prev = this.#migrationLock;
+    this.#migrationLock = next;
+    await prev;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+  async session(fn) {
+    if (sessionActiveStore.getStore()) return fn();
+    const snap = this.#snapshot();
+    try {
+      return await sessionActiveStore.run(true, fn);
+    } catch (error) {
+      this.#restore(snap);
+      throw error;
+    }
+  }
+};
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { FilterGroup: FilterGroup2 } = null;
+  const { OrderBy } = null;
+  const { Schema } = null;
+  const { IncOp: IncOp2, PatchOp: PatchOp2, PullOp: PullOp2, PushOp: PushOp2 } = null;
+  const { v: v7 } = null;
+  describe("in-memory adapter", () => {
+    test("InMemoryAdapter.create({}) produces a working adapter", () => {
+      const adapter = InMemoryAdapter.create({});
+      expect(adapter).toBeInstanceOf(InMemoryAdapter);
+      expect(adapter.schemaConfigPipe).toBeDefined();
+      expect(adapter.supportedFieldTypes).toEqual(["string", "number", "boolean", "null", "object", "array", "date"]);
+    });
+    test("supports nested filters, ordering, select, offset and limit", async () => {
+      const schema = Schema.from("users").pk("id", v7.string(), () => "u").field("name", v7.string()).field("age", v7.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "users" });
+      await use.createMany([
+        { id: "u1", name: "Alice", age: 30 },
+        { id: "u2", name: "Bob", age: 20 },
+        { id: "u3", name: "Carol", age: 40 }
+      ]);
+      const builtGroup = FilterGroup2.create().and([
+        (q) => q.gt("age", 19),
+        (q) => q.or([(g) => g.eq("name", "Alice"), (g) => g.eq("name", "Carol")])
+      ]);
+      const options = { orderBy: [new OrderBy("age", "desc")], offset: 1, limit: 1, select: ["id", "name"] };
+      const rows = await use.findMany(builtGroup, options);
+      expect(rows).toEqual([{ id: "u1", name: "Alice" }]);
+    });
+    test("count returns the number of matching rows without query options", async () => {
+      const schema = Schema.from("count_users").pk("id", v7.string(), () => "u").field("name", v7.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "count_users" });
+      await use.createMany([
+        { id: "u1", name: "Alice" },
+        { id: "u2", name: "Bob" },
+        { id: "u3", name: "Alice" }
+      ]);
+      await expect(use.count(FilterGroup2.create().eq("name", "Alice"))).resolves.toBe(2);
+    });
+    test("iterateMany with batchSize matches findMany filtering ordering offset limit and selection", async () => {
+      const schema = Schema.from("iter_users").pk("id", v7.string(), () => "u").field("name", v7.string()).field("age", v7.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "iter_users" });
+      await use.createMany([
+        { id: "u1", name: "Alice", age: 30 },
+        { id: "u2", name: "Bob", age: 20 },
+        { id: "u3", name: "Carol", age: 40 },
+        { id: "u4", name: "Dan", age: 50 }
+      ]);
+      const filter = FilterGroup2.create().gt("age", 19);
+      const options = {
+        orderBy: [new OrderBy("age", "desc")],
+        offset: 1,
+        limit: 2,
+        select: ["id", "name"]
+      };
+      const expected = await use.findMany(filter, options);
+      const rows = [];
+      for await (const row of use.iterateMany(filter, { ...options, batchSize: 2 })) {
+        rows.push(row);
+      }
+      expect(rows).toEqual(expected);
+      expect(rows).toEqual([
+        { id: "u3", name: "Carol" },
+        { id: "u1", name: "Alice" }
+      ]);
+    });
+    test("supports update operators and rollback on failed session", async () => {
+      const schema = Schema.from("docs").pk("id", v7.string(), () => "d1").field("count", v7.number()).field("tags", v7.array(v7.string())).field("meta", v7.object({ a: v7.number() })).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "docs" });
+      await use.createOne({ id: "d1", count: 1, tags: ["x"], meta: { a: 1 } });
+      await adapter.session(async () => {
+        await use.updateOne(FilterGroup2.create().eq("id", "d1"), {
+          count: new IncOp2("count", 2),
+          tags: new PushOp2("tags", "y"),
+          meta: new PatchOp2("meta", { a: 9 })
+        });
+      });
+      await expect(
+        adapter.session(async () => {
+          await use.updateOne(FilterGroup2.create().eq("id", "d1"), { tags: new PullOp2("tags", "x") });
+          throw new Error("boom");
+        })
+      ).rejects.toThrow("boom");
+      const row = await use.findOne(FilterGroup2.create().eq("id", "d1"));
+      expect(row).toEqual({ id: "d1", count: 3, tags: ["x", "y"], meta: { a: 9 } });
+    });
+    test("notIn filter excludes matching values", async () => {
+      const schema = Schema.from("users").pk("id", v7.string(), () => "u").field("name", v7.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "users" });
+      await use.createMany([
+        { id: "u1", name: "Alice" },
+        { id: "u2", name: "Bob" },
+        { id: "u3", name: "Carol" }
+      ]);
+      const rows = await use.findMany(FilterGroup2.create().notIn("name", ["Alice", "Carol"]));
+      expect(rows).toHaveLength(1);
+      expect(rows[0].name).toBe("Bob");
+    });
+    test("exists / notExists filter ops work correctly", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => "i").field("val", v7.optional(v7.string()), { onCreate: () => void 0 }).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", val: "present" },
+        { id: "i2", val: null },
+        { id: "i3", val: void 0 }
+      ]);
+      const existsRows = await use.findMany(FilterGroup2.create().exists("val"));
+      expect(existsRows).toHaveLength(1);
+      expect(existsRows[0].id).toBe("i1");
+      const notExistsRows = await use.findMany(FilterGroup2.create().notExists("val"));
+      expect(notExistsRows).toHaveLength(2);
+    });
+    test("findByPk returns seeded document and null for missing", async () => {
+      const schema = Schema.from("test").pk("id", v7.string(), () => "gen").build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "test" });
+      await use.createOne({ id: "x" });
+      const found = await adapter.findByPk(schema, { table: "test" }, "x");
+      expect(found).toEqual({ id: "x" });
+      const missing = await adapter.findByPk(schema, { table: "test" }, "missing");
+      expect(missing).toBeNull();
+    });
+    test("auto-wired Instance hooks register correctly keyed by class", async () => {
+      const { Instance: Inst } = await null;
+      const onSpy = (await null).vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      InMemoryAdapter.create({});
+      expect(onSpy).not.toHaveBeenCalled();
+      onSpy.mockRestore();
+    });
+    test("declares aggregateOps with all six canonical ops", () => {
+      const adapter = InMemoryAdapter.create({});
+      expect(adapter.aggregateOps).toEqual(["count", "countDistinct", "sum", "avg", "min", "max"]);
+    });
+    test("aggregate count returns correct total", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => `i-${Math.random().toString(36).slice(2, 8)}`).field("category", v7.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", category: "A" },
+        { id: "i2", category: "B" },
+        { id: "i3", category: "A" }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ total: 3 }]);
+    });
+    test("aggregate count with where filter", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => `i-${Math.random().toString(36).slice(2, 8)}`).field("category", v7.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", category: "A" },
+        { id: "i2", category: "B" },
+        { id: "i3", category: "A" }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: [],
+        where: FilterGroup2.create().eq("category", "A")
+      });
+      expect(result).toEqual([{ total: 2 }]);
+    });
+    test("aggregate count on empty store returns zero", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => "x").build();
+      const adapter = InMemoryAdapter.create({});
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ total: 0 }]);
+    });
+    test("aggregate sum/avg/min/max compute correctly", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => "x").field("price", v7.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", price: 10 },
+        { id: "i2", price: 20 },
+        { id: "i3", price: 30 }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [
+          { fn: "sum", field: "price", alias: "total" },
+          { fn: "avg", field: "price", alias: "avg" },
+          { fn: "min", field: "price", alias: "low" },
+          { fn: "max", field: "price", alias: "high" }
+        ],
+        groupBy: []
+      });
+      expect(result).toEqual([{ total: 60, avg: 20, low: 10, high: 30 }]);
+    });
+    test("aggregate countDistinct counts unique values", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => "x").field("category", v7.string()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", category: "A" },
+        { id: "i2", category: "B" },
+        { id: "i3", category: "A" }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "items" }, {
+        aggregates: [{ fn: "countDistinct", field: "category", alias: "unique" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ unique: 2 }]);
+    });
+    test("aggregate groupBy produces per-group results", async () => {
+      const schema = Schema.from("orders").pk("id", v7.string(), () => "x").field("region", v7.string()).field("amount", v7.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "orders" });
+      await use.createMany([
+        { id: "o1", region: "US", amount: 10 },
+        { id: "o2", region: "EU", amount: 20 },
+        { id: "o3", region: "US", amount: 30 }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [
+          { fn: "count", alias: "cnt" },
+          { fn: "sum", field: "amount", alias: "total" }
+        ],
+        groupBy: ["region"]
+      });
+      expect(result).toHaveLength(2);
+      const us = result.find((r) => r.region === "US");
+      const eu = result.find((r) => r.region === "EU");
+      expect(us).toEqual({ region: "US", cnt: 2, total: 40 });
+      expect(eu).toEqual({ region: "EU", cnt: 1, total: 20 });
+    });
+    test("aggregate having filters post-aggregation", async () => {
+      const schema = Schema.from("orders").pk("id", v7.string(), () => "x").field("region", v7.string()).field("amount", v7.number()).build();
+      const adapter = InMemoryAdapter.create({});
+      const use = adapter.use(schema, { table: "orders" });
+      await use.createMany([
+        { id: "o1", region: "US", amount: 10 },
+        { id: "o2", region: "EU", amount: 20 },
+        { id: "o3", region: "US", amount: 30 }
+      ]);
+      const result = await adapter.aggregate(schema, { table: "orders" }, {
+        aggregates: [{ fn: "sum", field: "amount", alias: "total" }],
+        groupBy: ["region"],
+        having: FilterGroup2.create().gt("total", 25)
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ region: "US", total: 40 });
+    });
+  });
+}
+
+// src/orm/adapters/json/index.ts
+var jsonConnectionPipe = () => import_valleyed6.v.object({
+  filePath: import_valleyed6.v.string()
+});
+var JsonAdapter = class extends configurable(jsonConnectionPipe, OrmAdapter) {
+  schemaConfigPipe = import_valleyed6.v.object({ table: import_valleyed6.v.string() });
+  #inMemory = InMemoryAdapter.create({});
+  supportedFieldTypes = this.#inMemory.supportedFieldTypes;
+  queryableOps = this.#inMemory.queryableOps;
+  updateOps = this.#inMemory.updateOps;
+  aggregateOps = this.#inMemory.aggregateOps;
+  #writeQueue = Promise.resolve();
+  constructor(config) {
+    super(config);
+  }
+  get stores() {
+    return this.#inMemory.stores;
+  }
+  #serialize() {
+    const obj = {};
+    const migrations = [...this.#inMemory.migrations.values()];
+    if (migrations.length > 0) obj["__migrations"] = migrations;
+    const tables = {};
+    for (const [name, meta] of this.#inMemory.tables.entries()) {
+      tables[name] = { pk: meta.pk, fields: Object.fromEntries(meta.fields.entries()) };
+    }
+    if (Object.keys(tables).length > 0) obj["__tables"] = tables;
+    const indexes = {};
+    for (const [name, meta] of this.#inMemory.indexes.entries()) {
+      indexes[name] = { table: meta.table, on: [...meta.on], unique: meta.unique };
+    }
+    if (Object.keys(indexes).length > 0) obj["__indexes"] = indexes;
+    const foreignKeys = {};
+    for (const [name, meta] of this.#inMemory.foreignKeys.entries()) {
+      foreignKeys[name] = {
+        table: meta.table,
+        on: meta.on,
+        references: meta.references,
+        ...meta.onDelete ? { onDelete: meta.onDelete } : {},
+        ...meta.onUpdate ? { onUpdate: meta.onUpdate } : {}
+      };
+    }
+    if (Object.keys(foreignKeys).length > 0) obj["__foreignKeys"] = foreignKeys;
+    for (const [name, store] of this.stores.entries()) {
+      const records = {};
+      for (const [pk, doc] of store.entries()) {
+        records[pk] = doc;
+      }
+      obj[name] = records;
+    }
+    return JSON.stringify(obj);
+  }
+  async #atomicWrite() {
+    const data = this.#serialize();
+    const tmpPath = this.config.filePath + ".tmp." + process.pid + "." + Date.now();
+    await (0, import_promises.writeFile)(tmpPath, data, "utf-8");
+    await (0, import_promises.rename)(tmpPath, this.config.filePath);
+  }
+  #persistToDisk() {
+    const next = this.#writeQueue.then(() => this.#atomicWrite());
+    this.#writeQueue = next.catch(() => {
+    });
+    return next;
+  }
+  async connect() {
+    let raw;
+    try {
+      raw = await (0, import_promises.readFile)(this.config.filePath, "utf-8");
+    } catch {
+      return;
+    }
+    const data = JSON.parse(raw);
+    this.#inMemory.migrations.clear();
+    if (Array.isArray(data["__migrations"])) {
+      for (const m of data["__migrations"]) {
+        this.#inMemory.migrations.set(m.id, { id: m.id, appliedAt: m.appliedAt });
+      }
+    }
+    this.#inMemory.tables.clear();
+    if (data["__tables"] && typeof data["__tables"] === "object") {
+      for (const [name, meta] of Object.entries(data["__tables"])) {
+        const fields = /* @__PURE__ */ new Map();
+        if (meta.fields) {
+          for (const [fieldName, fspec] of Object.entries(meta.fields)) {
+            fields.set(fieldName, fspec);
+          }
+        }
+        this.#inMemory.tables.set(name, { pk: meta.pk, fields });
+      }
+    }
+    this.#inMemory.indexes.clear();
+    if (data["__indexes"] && typeof data["__indexes"] === "object") {
+      for (const [name, meta] of Object.entries(data["__indexes"])) {
+        this.#inMemory.indexes.set(name, { table: meta.table, on: meta.on, unique: meta.unique });
+      }
+    }
+    this.#inMemory.foreignKeys.clear();
+    if (data["__foreignKeys"] && typeof data["__foreignKeys"] === "object") {
+      for (const [name, meta] of Object.entries(data["__foreignKeys"])) {
+        this.#inMemory.foreignKeys.set(name, meta);
+      }
+    }
+    this.stores.clear();
+    for (const [name, records] of Object.entries(data)) {
+      if (name.startsWith("__")) continue;
+      const store = /* @__PURE__ */ new Map();
+      for (const [pk, doc] of Object.entries(records)) {
+        store.set(pk, doc);
+      }
+      this.stores.set(name, store);
+    }
+  }
+  async disconnect() {
+    await this.#persistToDisk();
+  }
+  async findByPk(schema, config, pk) {
+    return this.#inMemory.findByPk(schema, config, pk);
+  }
+  async createMany(schema, config, data) {
+    const result = await this.#inMemory.createMany(schema, config, data);
+    await this.#persistToDisk();
+    return result;
+  }
+  async updateByPk(schema, config, pk, ops) {
+    const result = await this.#inMemory.updateByPk(schema, config, pk, ops);
+    if (result) await this.#persistToDisk();
+    return result;
+  }
+  async deleteByPk(schema, config, pk) {
+    const result = await this.#inMemory.deleteByPk(schema, config, pk);
+    if (result) await this.#persistToDisk();
+    return result;
+  }
+  async findMany(schema, config, group, options) {
+    return this.#inMemory.findMany(schema, config, group, options);
+  }
+  async count(schema, config, group) {
+    return this.#inMemory.count(schema, config, group);
+  }
+  iterateMany(schema, config, group, options) {
+    return this.#inMemory.iterateMany(schema, config, group, options);
+  }
+  async updateMany(schema, config, group, data) {
+    const result = await this.#inMemory.updateMany(schema, config, group, data);
+    if (result.length) await this.#persistToDisk();
+    return result;
+  }
+  async deleteMany(schema, config, filter) {
+    const result = await this.#inMemory.deleteMany(schema, config, filter);
+    if (result.length) await this.#persistToDisk();
+    return result;
+  }
+  async upsertOne(schema, config, filter, create, ops) {
+    const result = await this.#inMemory.upsertOne(schema, config, filter, create, ops);
+    await this.#persistToDisk();
+    return result;
+  }
+  async aggregate(schema, config, spec) {
+    return this.#inMemory.aggregate(schema, config, spec);
+  }
+  async session(fn) {
+    return this.#inMemory.session(async () => {
+      const result = await fn();
+      await this.#persistToDisk();
+      return result;
+    });
+  }
+  async loadMigrations() {
+    await this.connect();
+    return this.#inMemory.loadMigrations();
+  }
+  async recordMigration(id, appliedAt) {
+    await this.#inMemory.recordMigration(id, appliedAt);
+    await this.#persistToDisk();
+  }
+  async acquireMigrationLock(fn) {
+    const lockPath = this.config.filePath + ".lock";
+    const deadline = Date.now() + 3e4;
+    while (true) {
+      try {
+        const handle = await (0, import_promises.open)(lockPath, "wx");
+        await handle.close();
+        break;
+      } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+        if (Date.now() > deadline) throw new Error("Timed out waiting for migration lock");
+        await new Promise((r) => setTimeout(r, 50));
+      }
+    }
+    try {
+      return await fn();
+    } finally {
+      await (0, import_promises.unlink)(lockPath).catch(() => {
+      });
+    }
+  }
+  async applyCreateTable(change) {
+    await this.#inMemory.applyCreateTable(change);
+    await this.#persistToDisk();
+  }
+  async applyDropTable(change) {
+    await this.#inMemory.applyDropTable(change);
+    await this.#persistToDisk();
+  }
+  async applyAddField(change) {
+    await this.#inMemory.applyAddField(change);
+    await this.#persistToDisk();
+  }
+  async applyDropField(change) {
+    await this.#inMemory.applyDropField(change);
+    await this.#persistToDisk();
+  }
+  async applyModifyField(change) {
+    await this.#inMemory.applyModifyField(change);
+    await this.#persistToDisk();
+  }
+  async applyRenameTable(change) {
+    await this.#inMemory.applyRenameTable(change);
+    await this.#persistToDisk();
+  }
+  async applyRenameField(change) {
+    await this.#inMemory.applyRenameField(change);
+    await this.#persistToDisk();
+  }
+  async applyAddIndex(change) {
+    await this.#inMemory.applyAddIndex(change);
+    await this.#persistToDisk();
+  }
+  async applyDropIndex(change) {
+    await this.#inMemory.applyDropIndex(change);
+    await this.#persistToDisk();
+  }
+  async applyAddForeignKey(change) {
+    await this.#inMemory.applyAddForeignKey(change);
+    await this.#persistToDisk();
+  }
+  async applyDropForeignKey(change) {
+    await this.#inMemory.applyDropForeignKey(change);
+    await this.#persistToDisk();
+  }
+  async introspect() {
+    return this.#inMemory.introspect();
+  }
+};
+if (void 0) {
+  const { describe, test, expect, beforeEach, afterEach } = void 0;
+  const { FilterGroup: FilterGroup2 } = null;
+  const { OrderBy } = null;
+  const { Schema } = null;
+  const { IncOp: IncOp2, PatchOp: PatchOp2, PullOp: PullOp2, PushOp: PushOp2 } = null;
+  const { v: v7 } = null;
+  const { mkdtemp, rm } = null;
+  const { tmpdir } = null;
+  const { join } = null;
+  const { Migrator } = null;
+  const { Repo } = null;
+  const { OrmMigrationError } = null;
+  let tmpDir;
+  let filePath;
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "json-adapter-"));
+    filePath = join(tmpDir, "test.json");
+  });
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+  describe("json adapter \u2014 class construction", () => {
+    test("JsonAdapter.create({ filePath }) produces a working adapter", () => {
+      const adapter = JsonAdapter.create({ filePath });
+      expect(adapter).toBeInstanceOf(JsonAdapter);
+      expect(adapter.schemaConfigPipe).toBeDefined();
+      expect(adapter.supportedFieldTypes).toEqual(["string", "number", "boolean", "null", "object", "array", "date"]);
+    });
+    test("auto-wired Instance hooks register connect/disconnect keyed by class", async () => {
+      const { Instance: Inst } = await null;
+      const onSpy = (await null).vi.spyOn(Inst, "on").mockImplementation(() => {
+      });
+      JsonAdapter.create({ filePath });
+      expect(onSpy).toHaveBeenCalledWith("start", expect.any(Function), expect.objectContaining({ class: JsonAdapter }));
+      expect(onSpy).toHaveBeenCalledWith("close", expect.any(Function), expect.objectContaining({ class: JsonAdapter }));
+      onSpy.mockRestore();
+    });
+  });
+  describe("json adapter \u2014 surface parity with in-memory", () => {
+    test("CRUD: create, find, update, delete round-trip", async () => {
+      const schema = Schema.from("users").pk("id", v7.string(), () => "u").field("name", v7.string()).field("age", v7.number()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "users" });
+      const created = await use.createMany([
+        { id: "u1", name: "Alice", age: 30 },
+        { id: "u2", name: "Bob", age: 20 }
+      ]);
+      expect(created).toHaveLength(2);
+      const found = await use.findOne(FilterGroup2.create().eq("id", "u1"));
+      expect(found).toEqual({ id: "u1", name: "Alice", age: 30 });
+      const many = await use.findMany(FilterGroup2.create().gt("age", 19), {
+        orderBy: [new OrderBy("age", "asc")]
+      });
+      expect(many).toEqual([
+        { id: "u2", name: "Bob", age: 20 },
+        { id: "u1", name: "Alice", age: 30 }
+      ]);
+      await use.updateOne(FilterGroup2.create().eq("id", "u1"), { age: 31 });
+      const updated = await use.findOne(FilterGroup2.create().eq("id", "u1"));
+      expect(updated?.age).toBe(31);
+      const deleted = await use.deleteOne(FilterGroup2.create().eq("id", "u2"));
+      expect(deleted).toEqual({ id: "u2", name: "Bob", age: 20 });
+      const remaining = await use.findMany(FilterGroup2.create());
+      expect(remaining).toHaveLength(1);
+      await adapter.disconnect();
+    });
+    test("supports nested filters, ordering, select, offset and limit", async () => {
+      const schema = Schema.from("users").pk("id", v7.string(), () => "u").field("name", v7.string()).field("age", v7.number()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "users" });
+      await use.createMany([
+        { id: "u1", name: "Alice", age: 30 },
+        { id: "u2", name: "Bob", age: 20 },
+        { id: "u3", name: "Carol", age: 40 }
+      ]);
+      const builtGroup = FilterGroup2.create().and([
+        (q) => q.gt("age", 19),
+        (q) => q.or([(g) => g.eq("name", "Alice"), (g) => g.eq("name", "Carol")])
+      ]);
+      const options = { orderBy: [new OrderBy("age", "desc")], offset: 1, limit: 1, select: ["id", "name"] };
+      const rows = await use.findMany(builtGroup, options);
+      expect(rows).toEqual([{ id: "u1", name: "Alice" }]);
+      await adapter.disconnect();
+    });
+    test("count delegates to the in-memory store and persists separately from query options", async () => {
+      const schema = Schema.from("count_users").pk("id", v7.string(), () => "u").field("name", v7.string()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "count_users" });
+      await use.createMany([
+        { id: "u1", name: "Alice" },
+        { id: "u2", name: "Bob" },
+        { id: "u3", name: "Alice" }
+      ]);
+      await expect(use.count(FilterGroup2.create().eq("name", "Alice"))).resolves.toBe(2);
+      await adapter.disconnect();
+    });
+    test("iterateMany with batchSize matches findMany through in-memory delegation", async () => {
+      const schema = Schema.from("json_iter_users").pk("id", v7.string(), () => "u").field("name", v7.string()).field("age", v7.number()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "json_iter_users" });
+      await use.createMany([
+        { id: "u1", name: "Alice", age: 30 },
+        { id: "u2", name: "Bob", age: 20 },
+        { id: "u3", name: "Carol", age: 40 },
+        { id: "u4", name: "Dan", age: 50 }
+      ]);
+      const filter = FilterGroup2.create().gt("age", 19);
+      const options = {
+        orderBy: [new OrderBy("age", "desc")],
+        offset: 1,
+        limit: 2,
+        select: ["id", "name"]
+      };
+      const expected = await use.findMany(filter, options);
+      const rows = [];
+      for await (const row of use.iterateMany(filter, { ...options, batchSize: 2 })) {
+        rows.push(row);
+      }
+      expect(rows).toEqual(expected);
+      expect(rows).toEqual([
+        { id: "u3", name: "Carol" },
+        { id: "u1", name: "Alice" }
+      ]);
+      await adapter.disconnect();
+    });
+    test("supports update operators and rollback on failed session", async () => {
+      const schema = Schema.from("docs").pk("id", v7.string(), () => "d1").field("count", v7.number()).field("tags", v7.array(v7.string())).field("meta", v7.object({ a: v7.number() })).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "docs" });
+      await use.createOne({ id: "d1", count: 1, tags: ["x"], meta: { a: 1 } });
+      await adapter.session(async () => {
+        await use.updateOne(FilterGroup2.create().eq("id", "d1"), {
+          count: new IncOp2("count", 2),
+          tags: new PushOp2("tags", "y"),
+          meta: new PatchOp2("meta", { a: 9 })
+        });
+      });
+      await expect(
+        adapter.session(async () => {
+          await use.updateOne(FilterGroup2.create().eq("id", "d1"), { tags: new PullOp2("tags", "x") });
+          throw new Error("boom");
+        })
+      ).rejects.toThrow("boom");
+      const row = await use.findOne(FilterGroup2.create().eq("id", "d1"));
+      expect(row).toEqual({ id: "d1", count: 3, tags: ["x", "y"], meta: { a: 9 } });
+      await adapter.disconnect();
+    });
+    test("upsertOne inserts when missing and updates when existing", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => "i").field("val", v7.number()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "items" });
+      const inserted = await use.upsertOne(FilterGroup2.create().eq("id", "i1"), { id: "i1", val: 10 }, []);
+      expect(inserted).toEqual({ id: "i1", val: 10 });
+      const updated = await use.upsertOne(FilterGroup2.create().eq("id", "i1"), { id: "i1", val: 10 }, [new IncOp2("val", 5)]);
+      expect(updated).toEqual({ id: "i1", val: 15 });
+      await adapter.disconnect();
+    });
+  });
+  describe("json adapter \u2014 persistence", () => {
+    test("state persists across adapter restarts", async () => {
+      const schema = Schema.from("users").pk("id", v7.string(), () => "u").field("name", v7.string()).build();
+      const a1 = JsonAdapter.create({ filePath });
+      await a1.connect();
+      const use1 = a1.use(schema, { table: "users" });
+      await use1.createMany([
+        { id: "u1", name: "Alice" },
+        { id: "u2", name: "Bob" }
+      ]);
+      await a1.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      const use2 = a2.use(schema, { table: "users" });
+      const rows = await use2.findMany(FilterGroup2.create());
+      expect(rows).toHaveLength(2);
+      expect(rows.map((r) => r.name).sort()).toEqual(["Alice", "Bob"]);
+      await a2.disconnect();
+    });
+    test("failed session does not persist rolled-back state to disk", async () => {
+      const schema = Schema.from("docs").pk("id", v7.string(), () => "d").field("val", v7.number()).build();
+      const a1 = JsonAdapter.create({ filePath });
+      await a1.connect();
+      const use1 = a1.use(schema, { table: "docs" });
+      await use1.createOne({ id: "d1", val: 1 });
+      await a1.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      const use2 = a2.use(schema, { table: "docs" });
+      await expect(
+        a2.session(async () => {
+          await use2.updateOne(FilterGroup2.create().eq("id", "d1"), { val: 999 });
+          throw new Error("rollback");
+        })
+      ).rejects.toThrow("rollback");
+      await a2.disconnect();
+      const a3 = JsonAdapter.create({ filePath });
+      await a3.connect();
+      const use3 = a3.use(schema, { table: "docs" });
+      const row = await use3.findOne(FilterGroup2.create().eq("id", "d1"));
+      expect(row?.val).toBe(1);
+      await a3.disconnect();
+    });
+  });
+  describe("json adapter \u2014 atomic writes", () => {
+    test("file is valid JSON after every write", async () => {
+      const { readFile: rf } = await null;
+      const schema = Schema.from("items").pk("id", v7.string(), () => "i").field("val", v7.number()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "items" });
+      for (let i = 0; i < 10; i++) {
+        await use.createOne({ id: `i${i}`, val: i });
+        const raw = await rf(filePath, "utf-8");
+        expect(() => JSON.parse(raw)).not.toThrow();
+      }
+      await adapter.disconnect();
+    });
+    test("no .tmp files remain after writes complete", async () => {
+      const { readdir } = await null;
+      const schema = Schema.from("items").pk("id", v7.string(), () => "i").field("val", v7.number()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "items" });
+      for (let i = 0; i < 5; i++) {
+        await use.createOne({ id: `i${i}`, val: i });
+      }
+      await adapter.disconnect();
+      const files = await readdir(tmpDir);
+      const tmpFiles = files.filter((f) => f.includes(".tmp."));
+      expect(tmpFiles).toHaveLength(0);
+    });
+  });
+  describe("json adapter \u2014 aggregate delegation", () => {
+    const orderSchema = Schema.from("orders").pk("id", v7.string(), () => "o").field("amount", v7.number()).field("region", v7.string()).build();
+    const orderSeed = [
+      { id: "o1", amount: 100, region: "us" },
+      { id: "o2", amount: 200, region: "eu" },
+      { id: "o3", amount: 150, region: "us" }
+    ];
+    async function makeSeededAdapter() {
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(orderSchema, { table: "orders" });
+      await use.createMany(orderSeed);
+      return adapter;
+    }
+    test("aggregateOps matches in-memory adapter", () => {
+      const json = JsonAdapter.create({ filePath });
+      const inMem = InMemoryAdapter.create({});
+      expect(json.aggregateOps).toEqual(inMem.aggregateOps);
+      expect(json.aggregateOps).toEqual(["count", "countDistinct", "sum", "avg", "min", "max"]);
+    });
+    test("count returns identical result to in-memory", async () => {
+      const adapter = await makeSeededAdapter();
+      const result = await adapter.aggregate(orderSchema, { table: "orders" }, {
+        aggregates: [{ fn: "count", alias: "total" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ total: 3 }]);
+      await adapter.disconnect();
+    });
+    test("countDistinct returns identical result to in-memory", async () => {
+      const adapter = await makeSeededAdapter();
+      const result = await adapter.aggregate(orderSchema, { table: "orders" }, {
+        aggregates: [{ fn: "countDistinct", field: "region", alias: "uniqueRegions" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ uniqueRegions: 2 }]);
+      await adapter.disconnect();
+    });
+    test("sum, avg, min, max return identical results to in-memory", async () => {
+      const adapter = await makeSeededAdapter();
+      const result = await adapter.aggregate(orderSchema, { table: "orders" }, {
+        aggregates: [
+          { fn: "sum", field: "amount", alias: "totalAmount" },
+          { fn: "avg", field: "amount", alias: "avgAmount" },
+          { fn: "min", field: "amount", alias: "minAmount" },
+          { fn: "max", field: "amount", alias: "maxAmount" }
+        ],
+        groupBy: []
+      });
+      expect(result).toEqual([{ totalAmount: 450, avgAmount: 150, minAmount: 100, maxAmount: 200 }]);
+      await adapter.disconnect();
+    });
+    test("groupBy returns identical results to in-memory", async () => {
+      const adapter = await makeSeededAdapter();
+      const result = await adapter.aggregate(orderSchema, { table: "orders" }, {
+        aggregates: [
+          { fn: "count", alias: "cnt" },
+          { fn: "sum", field: "amount", alias: "total" }
+        ],
+        groupBy: ["region"]
+      });
+      const sorted = result.sort((a, b) => String(a.region).localeCompare(String(b.region)));
+      expect(sorted).toEqual([
+        { region: "eu", cnt: 1, total: 200 },
+        { region: "us", cnt: 2, total: 250 }
+      ]);
+      await adapter.disconnect();
+    });
+    test("where pre-filter returns identical results to in-memory", async () => {
+      const adapter = await makeSeededAdapter();
+      const result = await adapter.aggregate(orderSchema, { table: "orders" }, {
+        where: FilterGroup2.create().gt("amount", 100),
+        aggregates: [{ fn: "count", alias: "cnt" }],
+        groupBy: []
+      });
+      expect(result).toEqual([{ cnt: 2 }]);
+      await adapter.disconnect();
+    });
+    test("having post-filter returns identical results to in-memory", async () => {
+      const adapter = await makeSeededAdapter();
+      const result = await adapter.aggregate(orderSchema, { table: "orders" }, {
+        aggregates: [{ fn: "count", alias: "cnt" }],
+        groupBy: ["region"],
+        having: FilterGroup2.create().gt("cnt", 1)
+      });
+      expect(result).toEqual([{ region: "us", cnt: 2 }]);
+      await adapter.disconnect();
+    });
+    test("aggregate delegates to same in-memory instance used by CRUD", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => "i").field("val", v7.number()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "items" });
+      await use.createMany([
+        { id: "i1", val: 10 },
+        { id: "i2", val: 20 }
+      ]);
+      const spec = {
+        aggregates: [{ fn: "sum", field: "val", alias: "total" }],
+        groupBy: []
+      };
+      const result = await adapter.aggregate(schema, { table: "items" }, spec);
+      expect(result).toEqual([{ total: 30 }]);
+      await use.createOne({ id: "i3", val: 30 });
+      const result2 = await adapter.aggregate(schema, { table: "items" }, spec);
+      expect(result2).toEqual([{ total: 60 }]);
+      await adapter.disconnect();
+    });
+  });
+  describe("json adapter \u2014 concurrent writes serialize", () => {
+    test("parallel writes from same process all persist", async () => {
+      const schema = Schema.from("items").pk("id", v7.string(), () => "i").field("val", v7.number()).build();
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const use = adapter.use(schema, { table: "items" });
+      await Promise.all(Array.from({ length: 20 }, (_, i) => use.createOne({ id: `i${i}`, val: i })));
+      const rows = await use.findMany(FilterGroup2.create());
+      expect(rows).toHaveLength(20);
+      await adapter.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      const use2 = a2.use(schema, { table: "items" });
+      const reloaded = await use2.findMany(FilterGroup2.create());
+      expect(reloaded).toHaveLength(20);
+      await a2.disconnect();
+    });
+  });
+  describe("json adapter \u2014 migration storage", () => {
+    test("recordMigration + loadMigrations round-trip", async () => {
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      await adapter.recordMigration("m-001", 1e3);
+      await adapter.recordMigration("m-002", 2e3);
+      const loaded = await adapter.loadMigrations();
+      expect(loaded).toHaveLength(2);
+      expect(loaded).toEqual([
+        { id: "m-001", appliedAt: 1e3 },
+        { id: "m-002", appliedAt: 2e3 }
+      ]);
+      await adapter.disconnect();
+    });
+    test("migration tracker persists across adapter restarts", async () => {
+      const a1 = JsonAdapter.create({ filePath });
+      await a1.connect();
+      await a1.recordMigration("m-001", 1e3);
+      await a1.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      const loaded = await a2.loadMigrations();
+      expect(loaded).toEqual([{ id: "m-001", appliedAt: 1e3 }]);
+      await a2.disconnect();
+    });
+    test("__migrations key in JSON file stores tracker data", async () => {
+      const { readFile: rf } = await null;
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      await adapter.recordMigration("m-001", 1e3);
+      await adapter.disconnect();
+      const raw = JSON.parse(await rf(filePath, "utf-8"));
+      expect(raw["__migrations"]).toEqual([{ id: "m-001", appliedAt: 1e3 }]);
+    });
+  });
+  describe("json adapter \u2014 apply* methods", () => {
+    test("applyCreateTable persists table metadata", async () => {
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      await adapter.applyCreateTable({
+        kind: "createTable",
+        name: "users",
+        pk: { name: "id", type: "string" },
+        fields: [{ name: "email", type: "string", unique: true }]
+      });
+      await adapter.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      const schemas = await a2.introspect();
+      expect(schemas).toHaveLength(1);
+      expect(schemas[0].name).toBe("users");
+      expect(schemas[0].pk).toEqual({ name: "id", type: "string" });
+      expect(schemas[0].fields).toEqual([{ name: "email", type: "string", nullable: false, unique: true }]);
+      await a2.disconnect();
+    });
+    test("applyAddIndex and applyDropIndex persist across restarts", async () => {
+      const a1 = JsonAdapter.create({ filePath });
+      await a1.connect();
+      await a1.applyCreateTable({ kind: "createTable", name: "users", pk: { name: "id", type: "string" }, fields: [] });
+      await a1.applyAddIndex({ kind: "addIndex", table: "users", on: ["email"], unique: true });
+      await a1.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      const schemas = await a2.introspect();
+      expect(schemas[0].indexes).toEqual([{ name: "users_email_idx", on: ["email"], unique: true }]);
+      await a2.applyDropIndex({ kind: "dropIndex", name: "users_email_idx" });
+      await a2.disconnect();
+      const a3 = JsonAdapter.create({ filePath });
+      await a3.connect();
+      const schemas2 = await a3.introspect();
+      expect(schemas2[0].indexes).toEqual([]);
+      await a3.disconnect();
+    });
+    test("applyAddForeignKey and applyDropForeignKey persist across restarts", async () => {
+      const a1 = JsonAdapter.create({ filePath });
+      await a1.connect();
+      await a1.applyCreateTable({ kind: "createTable", name: "users", pk: { name: "id", type: "string" }, fields: [] });
+      await a1.applyCreateTable({ kind: "createTable", name: "posts", pk: { name: "id", type: "string" }, fields: [] });
+      await a1.applyAddForeignKey({ kind: "addForeignKey", table: "posts", on: "authorId", references: { table: "users", column: "id" }, onDelete: "cascade" });
+      await a1.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      const schemas = await a2.introspect();
+      const posts = schemas.find((s) => s.name === "posts");
+      expect(posts.foreignKeys).toEqual([{
+        name: "posts_authorId_fk",
+        on: "authorId",
+        references: { table: "users", column: "id" },
+        onDelete: "cascade"
+      }]);
+      await a2.applyDropForeignKey({ kind: "dropForeignKey", table: "posts", name: "posts_authorId_fk" });
+      await a2.disconnect();
+      const a3 = JsonAdapter.create({ filePath });
+      await a3.connect();
+      const schemas2 = await a3.introspect();
+      const posts2 = schemas2.find((s) => s.name === "posts");
+      expect(posts2.foreignKeys).toEqual([]);
+      await a3.disconnect();
+    });
+  });
+  describe("json adapter \u2014 acquireMigrationLock", () => {
+    test("file lock serialises concurrent calls", async () => {
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      const order = [];
+      let resolveGate;
+      const gate = new Promise((r) => {
+        resolveGate = r;
+      });
+      const p1 = adapter.acquireMigrationLock(async () => {
+        order.push("p1-start");
+        await gate;
+        order.push("p1-end");
+      });
+      await new Promise((r) => setTimeout(r, 100));
+      const p2 = adapter.acquireMigrationLock(async () => {
+        order.push("p2");
+      });
+      await new Promise((r) => setTimeout(r, 100));
+      expect(order).toEqual(["p1-start"]);
+      resolveGate();
+      await Promise.all([p1, p2]);
+      expect(order).toEqual(["p1-start", "p1-end", "p2"]);
+      await adapter.disconnect();
+    });
+    test("lock file is cleaned up after successful execution", async () => {
+      const { access } = await null;
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      await adapter.acquireMigrationLock(async () => {
+      });
+      await expect(access(filePath + ".lock")).rejects.toThrow();
+      await adapter.disconnect();
+    });
+    test("lock file is cleaned up after failed execution", async () => {
+      const { access } = await null;
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      await expect(
+        adapter.acquireMigrationLock(async () => {
+          throw new Error("boom");
+        })
+      ).rejects.toThrow("boom");
+      await expect(access(filePath + ".lock")).rejects.toThrow();
+      await adapter.disconnect();
+    });
+  });
+  describe("json adapter \u2014 end-to-end migrations via Migrator", () => {
+    const UserSchema = Schema.from("users").pk("id", v7.string(), () => `u-${Math.random().toString(36).slice(2)}`).field("email", v7.string()).build();
+    function makeEnv() {
+      const adapter = JsonAdapter.create({ filePath });
+      const repo = new Repo({ adapter, resolve: (s) => ({ table: s.name }) });
+      return { adapter, repo };
+    }
+    test("end-to-end migration run covering every declarative variant + execute", async () => {
+      const { adapter, repo } = makeEnv();
+      await adapter.connect();
+      const migrations = [
+        {
+          id: "0001-create",
+          changes: [
+            { kind: "createTable", name: "users", pk: { name: "id", type: "string" }, fields: [{ name: "email", type: "string" }] },
+            { kind: "createTable", name: "posts", pk: { name: "id", type: "string" }, fields: [{ name: "title", type: "string" }, { name: "authorId", type: "string" }] },
+            { kind: "addIndex", table: "users", on: ["email"], unique: true },
+            { kind: "addForeignKey", table: "posts", on: "authorId", references: { table: "users", column: "id" } }
+          ]
+        },
+        {
+          id: "0002-evolve",
+          changes: [
+            { kind: "addField", table: "users", field: { name: "age", type: "number", nullable: true } },
+            { kind: "modifyField", table: "users", name: "email", to: { name: "email", type: "string", unique: true, nullable: true } },
+            { kind: "renameField", table: "posts", from: "title", to: "headline" },
+            { kind: "renameTable", from: "posts", to: "articles" }
+          ]
+        },
+        {
+          id: "0003-cleanup",
+          changes: [
+            { kind: "dropField", table: "users", name: "age" },
+            { kind: "dropForeignKey", table: "posts", name: "posts_authorId_fk" },
+            { kind: "dropIndex", name: "users_email_idx" },
+            { kind: "dropTable", name: "articles" }
+          ]
+        },
+        {
+          id: "0004-seed",
+          changes: [{
+            kind: "execute",
+            up: async (r) => {
+              await r.on(UserSchema).one().create({ id: "seed-1", email: "test@example.com" });
+            }
+          }]
+        }
+      ];
+      const migrator = Migrator.from(repo, adapter).migrations(migrations).build();
+      const result = await migrator.up();
+      expect(result.ran).toEqual(["0001-create", "0002-evolve", "0003-cleanup", "0004-seed"]);
+      const recorded = await adapter.loadMigrations();
+      expect(recorded).toHaveLength(4);
+      const row = await repo.on(UserSchema).one().id("seed-1").find();
+      expect(row).not.toBeNull();
+      expect(row.email).toBe("test@example.com");
+      await adapter.disconnect();
+      const { adapter: a2, repo: r2 } = makeEnv();
+      await a2.connect();
+      const recorded2 = await a2.loadMigrations();
+      expect(recorded2).toHaveLength(4);
+      const row2 = await r2.on(UserSchema).one().id("seed-1").find();
+      expect(row2.email).toBe("test@example.com");
+      await a2.disconnect();
+    });
+    test("file lock serialises concurrent migrator.up() runs", async () => {
+      const order = [];
+      let resolveGate;
+      const gate = new Promise((r) => {
+        resolveGate = r;
+      });
+      const migrations = [
+        {
+          id: "0001",
+          changes: [{
+            kind: "execute",
+            up: async () => {
+              order.push("0001-start");
+              await gate;
+              order.push("0001-end");
+            }
+          }]
+        },
+        {
+          id: "0002",
+          changes: [{ kind: "execute", up: async () => {
+            order.push("0002");
+          } }]
+        }
+      ];
+      const adapter1 = JsonAdapter.create({ filePath });
+      await adapter1.connect();
+      const repo1 = new Repo({ adapter: adapter1, resolve: (s) => ({ table: s.name }) });
+      const migrator1 = Migrator.from(repo1, adapter1).migrations(migrations).build();
+      const adapter2 = JsonAdapter.create({ filePath });
+      await adapter2.connect();
+      const repo2 = new Repo({ adapter: adapter2, resolve: (s) => ({ table: s.name }) });
+      const migrator2 = Migrator.from(repo2, adapter2).migrations(migrations).build();
+      const p1 = migrator1.up();
+      const p2 = migrator2.up();
+      await new Promise((r) => setTimeout(r, 200));
+      expect(order).toEqual(["0001-start"]);
+      resolveGate();
+      await Promise.all([p1, p2]);
+      expect(order).toEqual(["0001-start", "0001-end", "0002"]);
+      await adapter1.disconnect();
+      await adapter2.disconnect();
+    });
+    test("tx:true rollback leaves file unchanged on failure", async () => {
+      const { adapter } = makeEnv();
+      await adapter.connect();
+      await adapter.applyCreateTable({ kind: "createTable", name: "users", pk: { name: "id", type: "string" }, fields: [] });
+      await adapter.disconnect();
+      const { adapter: a2, repo: r2 } = makeEnv();
+      await a2.connect();
+      const m = {
+        id: "0001-will-fail",
+        changes: [
+          { kind: "addIndex", table: "users", on: ["email"] },
+          {
+            kind: "execute",
+            up: async (r) => {
+              await r.on(UserSchema).one().create({ id: "partial", email: "fail@test.com" });
+              throw new Error("mid-migration boom");
+            }
+          }
+        ]
+      };
+      const migrator = Migrator.from(r2, a2).migrations([m]).build();
+      await expect(migrator.up()).rejects.toThrow(OrmMigrationError);
+      await a2.disconnect();
+      const { adapter: a3, repo: r3 } = makeEnv();
+      await a3.connect();
+      const recorded = await a3.loadMigrations();
+      expect(recorded).toHaveLength(0);
+      const schemas = await a3.introspect();
+      const users = schemas.find((s) => s.name === "users");
+      expect(users.indexes).toEqual([]);
+      const row = await r3.on(UserSchema).one().id("partial").find();
+      expect(row).toBeNull();
+      await a3.disconnect();
+    });
+    test("introspect() round-trip: apply* then introspect returns matching descriptors", async () => {
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      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 }
+        ]
+      });
+      await adapter.applyAddIndex({ kind: "addIndex", table: "users", on: ["email"], unique: true });
+      await adapter.applyCreateTable({
+        kind: "createTable",
+        name: "posts",
+        pk: { name: "id", type: "string" },
+        fields: [{ name: "authorId", type: "string" }]
+      });
+      await adapter.applyAddForeignKey({
+        kind: "addForeignKey",
+        table: "posts",
+        on: "authorId",
+        references: { table: "users", column: "id" },
+        onDelete: "cascade"
+      });
+      await adapter.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      const schemas = await a2.introspect();
+      const users = schemas.find((s) => s.name === "users");
+      expect(users.pk).toEqual({ name: "id", type: "string" });
+      expect(users.fields).toEqual([
+        { name: "email", type: "string", nullable: false, unique: true },
+        { name: "age", type: "number", nullable: true }
+      ]);
+      expect(users.indexes).toEqual([{ name: "users_email_idx", on: ["email"], unique: true }]);
+      const posts = schemas.find((s) => s.name === "posts");
+      expect(posts.pk).toEqual({ name: "id", type: "string" });
+      expect(posts.fields).toEqual([{ name: "authorId", type: "string", nullable: false }]);
+      expect(posts.foreignKeys).toEqual([{
+        name: "posts_authorId_fk",
+        on: "authorId",
+        references: { table: "users", column: "id" },
+        onDelete: "cascade"
+      }]);
+      await a2.disconnect();
+    });
+    test("metadata keys do not leak into data stores", async () => {
+      const adapter = JsonAdapter.create({ filePath });
+      await adapter.connect();
+      await adapter.recordMigration("m-001", 1e3);
+      await adapter.applyCreateTable({ kind: "createTable", name: "users", pk: { name: "id", type: "string" }, fields: [] });
+      expect(adapter.stores.has("__migrations")).toBe(false);
+      expect(adapter.stores.has("__tables")).toBe(false);
+      await adapter.disconnect();
+      const a2 = JsonAdapter.create({ filePath });
+      await a2.connect();
+      expect(a2.stores.has("__migrations")).toBe(false);
+      expect(a2.stores.has("__tables")).toBe(false);
+      await a2.disconnect();
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonAdapter
+});
+//# sourceMappingURL=index.cjs.map