reylo-effect-tooling 0.0.0-stage → 0.5.1

package/dist/esbuild.js

@@ -0,0 +1,3662 @@
+// src/esbuild.ts
+import { Effect as Effect8, FileSystem as FileSystem4 } from "effect";
+
+// src/emit.ts
+import { dirname as dirname4, join as join6, resolve as resolve3 } from "node:path";
+import { Effect as Effect7, FileSystem as FileSystem3, Option as Option6 } from "effect";
+
+// src/analysis.ts
+import { createHash as createHash3, randomUUID } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname3, join as join5, posix, relative as relative2, resolve as resolve2, sep } from "node:path";
+import {
+  Effect as Effect3,
+  Exit,
+  FileSystem as FileSystem2,
+  Option as Option4,
+  Path as Path2,
+  Predicate as Predicate4,
+  RcRef,
+  Ref,
+  Schema as Schema4,
+  Scope
+} from "effect";
+import { isMap, isNode, isScalar, parseDocument } from "yaml";
+
+// src/reylo-engine.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Predicate } from "effect";
+var ENGINE_VERSION = "0.5.0";
+var ENGINE_PACKAGES = {
+  postgres: "@reylosql/postgres",
+  sqlite: "@reylosql/sqlite",
+  mysql: "@reylosql/mysql"
+};
+var UNREACHABLE = /* @__PURE__ */ Symbol.for("reylo.unreachable");
+var NOT_MYSQL = /* @__PURE__ */ Symbol.for("reylo.not-mysql");
+var Unreachable = class extends Error {
+  [UNREACHABLE] = true;
+  constructor(cause) {
+    super(reason(cause), { cause });
+  }
+};
+function isUnreachable(cause) {
+  return UNREACHABLE in cause && cause[UNREACHABLE] === true;
+}
+function isNotMysql(cause) {
+  return NOT_MYSQL in cause && cause[NOT_MYSQL] === true && "server" in cause && Predicate.isString(cause.server);
+}
+function reason(cause) {
+  const own = messageOf(cause);
+  if (own !== "") return own;
+  if (Predicate.hasProperty(cause, "errors") && Array.isArray(cause.errors)) {
+    const joined = cause.errors.map(messageOf).filter((message) => message !== "").join("; ");
+    if (joined !== "") return joined;
+  }
+  if (Predicate.hasProperty(cause, "code") && Predicate.isString(cause.code) && cause.code !== "")
+    return cause.code;
+  return String(cause);
+}
+function messageOf(cause) {
+  return Predicate.hasProperty(cause, "message") && Predicate.isString(cause.message) ? cause.message : "";
+}
+var MissingEngine = class _MissingEngine extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MissingEngine";
+  }
+  static of(dialect) {
+    const pkg = ENGINE_PACKAGES[dialect];
+    return new _MissingEngine(
+      `${dialect} statements need ${pkg} ${ENGINE_VERSION}: npm install -D ${pkg}@${ENGINE_VERSION}`
+    );
+  }
+  static none() {
+    return new _MissingEngine(
+      "reylo reads the project file with a database's engine, and none is installed: npm install -D @reylosql/postgres, @reylosql/mysql or @reylosql/sqlite, the one for your database"
+    );
+  }
+};
+var AnswerCache = class {
+  #entries = /* @__PURE__ */ new Map();
+  async get(need, fetch) {
+    const ttl = need.kind === "query" && need.scope === "session" ? 6e4 : 5e3;
+    const hit = this.#entries.get(need.id);
+    if (hit && Date.now() - hit.at < ttl) return hit.answer;
+    const answer = await fetch();
+    if (!("error" in answer)) this.#entries.set(need.id, { at: Date.now(), answer });
+    return answer;
+  }
+  clear() {
+    this.#entries.clear();
+  }
+};
+async function fulfil(need, io) {
+  try {
+    if (need.kind === "describe") {
+      const described = await io.describe(need.sql);
+      if ("kind" in described)
+        return { mysql: { columns: described.columns, params: described.params } };
+      return {
+        describe: {
+          params: described.params.map((param) => param.oid),
+          columns: described.columns
+        }
+      };
+    }
+    return { rows: await io.query(need.sql, need.params) };
+  } catch (cause) {
+    if (cause instanceof Error && isUnreachable(cause)) throw cause;
+    const error = { message: reason(cause) };
+    if (Predicate.hasProperty(cause, "code") && Predicate.isString(cause.code))
+      error.code = cause.code;
+    if (Predicate.hasProperty(cause, "position") && cause.position !== void 0)
+      error.position = Number(cause.position);
+    return { error };
+  }
+}
+var WASI_WARNING = "WASI is an experimental feature and might change at any time";
+function loadWasi() {
+  const original = Object.getOwnPropertyDescriptor(process, "emitWarning");
+  const emitWarning = process.emitWarning.bind(process);
+  const filtered = (warning, ...rest) => {
+    const message = Predicate.isString(warning) ? warning : warning.message;
+    const [options] = rest;
+    const type = !Predicate.isString(warning) ? warning.name : Predicate.isString(options) ? options : Predicate.hasProperty(options, "type") ? options.type : void 0;
+    if (message === WASI_WARNING && type === "ExperimentalWarning") return;
+    emitWarning(...[warning, ...rest]);
+  };
+  process.emitWarning = filtered;
+  try {
+    return process.getBuiltinModule("node:wasi");
+  } finally {
+    if (original) Object.defineProperty(process, "emitWarning", original);
+  }
+}
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var Engine = class _Engine {
+  #exports;
+  constructor(exports) {
+    this.#exports = exports;
+  }
+  static async load(path) {
+    const module = await WebAssembly.compile(readFileSync(path));
+    const { WASI } = loadWasi();
+    const wasi = new WASI({ version: "preview1", args: ["reylo-engine"], env: {} });
+    const imports = wasi.getImportObject();
+    const instance = await WebAssembly.instantiate(module, imports);
+    wasi.initialize(instance);
+    return new _Engine(instance.exports);
+  }
+  call(request) {
+    const { memory, reylo_alloc, reylo_free, reylo_call } = this.#exports;
+    const bytes2 = encoder.encode(JSON.stringify(request));
+    const pointer = reylo_alloc(bytes2.length);
+    new Uint8Array(memory.buffer, pointer, bytes2.length).set(bytes2);
+    const out = reylo_call(pointer, bytes2.length);
+    reylo_free(pointer, bytes2.length);
+    const length = new DataView(memory.buffer).getUint32(out, true);
+    const text = decoder.decode(new Uint8Array(memory.buffer, out + 4, length));
+    reylo_free(out, length + 4);
+    return JSON.parse(text);
+  }
+  lex(sql, dialect) {
+    const response = this.call({ op: "lex", sql, dialect });
+    if (response.status !== "lexed") throw new Error(failureOf(response));
+    return response.lexed;
+  }
+  /** Analyze one statement, fulfilling the engine's needs through `io` until it answers. */
+  async analyze(sql, dialect, io, cache = new AnswerCache()) {
+    const answers = {};
+    for (let round = 0; round < 16; round++) {
+      const response = this.call({ op: "analyze", sql, dialect, answers });
+      if (response.status === "analysis") return response.analysis;
+      if (response.status !== "need") throw new Error(failureOf(response));
+      await Promise.all(
+        response.needs.map(async (need) => {
+          answers[need.id] = await cache.get(need, () => fulfil(need, io));
+        })
+      );
+    }
+    throw new Error("the analysis engine did not converge");
+  }
+};
+function failureOf(response) {
+  return response.status === "error" ? response.message : `unexpected ${response.status}`;
+}
+function enginePath(dialect, projectDir) {
+  return resolveFrom(projectDir, `${ENGINE_PACKAGES[dialect]}/engine.wasm`);
+}
+function resolveFrom(projectDir, specifier) {
+  for (const base of [fileURLToPath(import.meta.url), join(projectDir, "package.json")]) {
+    try {
+      return createRequire(base).resolve(specifier);
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+async function describer(dialect, projectDir) {
+  const path = resolveFrom(projectDir, `${ENGINE_PACKAGES[dialect]}/describe`);
+  if (path === void 0) throw MissingEngine.of(dialect);
+  return await import(pathToFileURL(path).href);
+}
+function sqlitePackageDir(projectDir) {
+  const path = resolveFrom(projectDir, "@reylosql/sqlite/package.json");
+  return path === void 0 ? void 0 : dirname(path);
+}
+var engines = /* @__PURE__ */ new Map();
+function engine(dialect, projectDir) {
+  const path = enginePath(dialect, projectDir);
+  if (path === void 0) return Promise.reject(MissingEngine.of(dialect));
+  let loading = engines.get(path);
+  if (loading === void 0) {
+    loading = loadEngine(dialect, path);
+    loading.catch(() => engines.delete(path));
+    engines.set(path, loading);
+  }
+  return loading;
+}
+async function loadEngine(dialect, path) {
+  const pkg = ENGINE_PACKAGES[dialect];
+  const version = packageVersion(join(dirname(path), "package.json"));
+  if (version !== ENGINE_VERSION) {
+    throw new MissingEngine(
+      `reylo-effect runs with ${pkg} ${ENGINE_VERSION}, and the one installed is ${version ?? "of no version"} (${dirname(path)}): npm install -D ${pkg}@${ENGINE_VERSION}`
+    );
+  }
+  const loaded = await Engine.load(path);
+  const ping = loaded.call({ op: "ping" });
+  if (ping.status !== "ok" || ping.database !== dialect) {
+    const reads = ping.status === "ok" && ping.database ? `${ping.database} statements` : "no one database's statements";
+    throw new MissingEngine(
+      `${pkg} (${dirname(path)}) carries an engine that reads ${reads}, not ${dialect} ones: npm install -D ${pkg}@${ENGINE_VERSION}`
+    );
+  }
+  return loaded;
+}
+function packageVersion(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return Predicate.hasProperty(parsed, "version") && Predicate.isString(parsed.version) ? parsed.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function anyEngine(projectDir) {
+  let failed;
+  for (const dialect of ["postgres", "mysql", "sqlite"]) {
+    if (enginePath(dialect, projectDir) === void 0) continue;
+    try {
+      return await engine(dialect, projectDir);
+    } catch (cause) {
+      failed ??= cause instanceof MissingEngine ? cause : new MissingEngine(reason(cause));
+    }
+  }
+  return failed ?? MissingEngine.none();
+}
+var PROJECT_FILES = [".reylo.yaml", ".reylo.yml"];
+var DEFAULT_ENV_FILES = [".env.local", ".env"];
+function packageDir(from) {
+  for (let dir = resolve(from); ; dir = dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) return dir;
+    if (dirname(dir) === dir) return resolve(from);
+  }
+}
+function findProjectFile(from, env) {
+  if (env.REYLO_CONFIG) return resolve(env.REYLO_CONFIG);
+  const dir = packageDir(from);
+  return PROJECT_FILES.map((name) => join(dir, name)).find((path) => existsSync(path));
+}
+function dialectOf(url) {
+  const scheme = /^([a-z][a-z0-9+.-]*):/iu.exec(url)?.[1]?.toLowerCase();
+  if (scheme === "postgres" || scheme === "postgresql") return "postgres";
+  if (scheme === "mysql" || scheme === "mariadb") return "mysql";
+  if (scheme === "file" || scheme === "sqlite") return "sqlite";
+  return void 0;
+}
+function readEnvFile(path) {
+  const out = /* @__PURE__ */ new Map();
+  if (!existsSync(path)) return out;
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/u.exec(line);
+    if (match) out.set(match[1], match[2].replace(/^(["'])(.*)\1$/u, "$2"));
+  }
+  return out;
+}
+function place(text, offset) {
+  const lines = Buffer.from(text, "utf8").subarray(0, offset).toString("utf8").split("\n");
+  return `${lines.length}:${lines.at(-1).length + 1}`;
+}
+var TYPES_KEY = /^types[ \t]*:/mu;
+function resolveNativeProject(host2, projectDir, env = process.env, configText = (text) => text) {
+  const file = findProjectFile(projectDir, env);
+  const root = file ? dirname(file) : packageDir(projectDir);
+  const shown = (path) => isAbsolute(path) ? relative(projectDir, path) || path : path;
+  let config = {};
+  let error;
+  if (file) {
+    let text;
+    try {
+      text = readFileSync(file, "utf8");
+    } catch (cause) {
+      error = `Cannot read ${shown(file)}: ${reason(cause)}`;
+    }
+    const types = text === void 0 ? null : TYPES_KEY.exec(text);
+    if (text !== void 0 && types) {
+      error = `${shown(file)}:${place(text, Buffer.byteLength(text.slice(0, types.index)))}: types: the types section was removed on 2026-10-20. Reylo now gives every value one type on every driver, whatever the driver's settings: a 64-bit integer is a BigInt, a decimal its exact text, a timestamptz its ISO 8601 text in UTC, a date and a timestamp their text, JSON parsed and binary data a Uint8Array. Delete the section.`;
+    } else if (text !== void 0) {
+      if (host2 instanceof MissingEngine) error = `${shown(file)}: ${host2.message}`;
+      else {
+        const read = configText(text);
+        const response = host2.call({ op: "config", text: read });
+        if (response.status === "config") config = response.config;
+        else if (response.status === "configError")
+          error = `${shown(file)}:${place(read, response.error.start)}: ${response.error.message}`;
+        else error = `${shown(file)}: ${failureOf(response)}`;
+      }
+    }
+  }
+  const both = PROJECT_FILES.map((name) => join(root, name));
+  if (!env.REYLO_CONFIG && both.every((path) => existsSync(path)))
+    error = `${both.map(shown).join(" and ")} are both project files; keep one.`;
+  const envFiles = (config.env ?? DEFAULT_ENV_FILES).map((name) => resolve(root, name));
+  const envValues = /* @__PURE__ */ new Map();
+  const lookup = (name) => {
+    const set = env[name];
+    if (set !== void 0) return { value: set, source: `${name} in the environment` };
+    for (const path of envFiles) {
+      let values = envValues.get(path);
+      if (values === void 0) {
+        values = readEnvFile(path);
+        envValues.set(path, values);
+      }
+      const value = values.get(name);
+      if (value !== void 0) return { value, source: `${name} in ${shown(path)}` };
+    }
+    return void 0;
+  };
+  const fileName = file === void 0 ? ".reylo.yaml" : shown(file);
+  const urlAlone = config.url !== void 0 && config.direct_url === void 0;
+  const notice = urlAlone ? `${fileName}: Reylo does not read url; set direct_url to the dev database Reylo reads your types from (it uses DATABASE_URL meanwhile)` : void 0;
+  const missingUrl = urlAlone ? `No database URL: ${fileName} sets url, which Reylo does not read; set direct_url there, or DATABASE_URL in the environment, .env.local or .env.` : `No database URL: set DATABASE_URL in the environment, .env.local or .env, or "direct_url" in ${fileName}.`;
+  let url;
+  let urlSource = "DATABASE_URL";
+  if (config.direct_url !== void 0) {
+    const missing = [];
+    const sources = [];
+    url = config.direct_url.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/gu, (_, name) => {
+      const hit = lookup(name);
+      if (hit) sources.push(hit.source);
+      else missing.push(name);
+      return hit?.value ?? "";
+    });
+    urlSource = `"direct_url" in ${fileName}${sources.length > 0 ? `, ${sources.join(", ")}` : ""}`;
+    if (missing.length > 0) {
+      error ??= `${fileName}: "direct_url" names ${missing.map((name) => `\${${name}}`).join(", ")}, which neither the environment nor ${envFiles.map(shown).join(" nor ")} sets.`;
+      url = void 0;
+    }
+  } else {
+    const hit = lookup("DATABASE_URL");
+    url = hit?.value;
+    if (hit) urlSource = hit.source;
+  }
+  let dialect = url ? dialectOf(url) : "postgres";
+  if (url && !dialect)
+    error ??= `Cannot tell the database from the URL (${urlSource}): reylo reads postgres://, postgresql://, mysql://, file: and sqlite: URLs.`;
+  const watched = [.../* @__PURE__ */ new Set([...file ? [file] : [], ...both]), ...envFiles];
+  if (!url) dialect = offlineDialect(root) ?? dialect;
+  return {
+    file,
+    root,
+    dialect: dialect ?? "postgres",
+    strictParams: config.strict_params ?? true,
+    sqlcommenter: config.sqlcommenter ?? true,
+    cli: config.cli ?? {},
+    url,
+    urlSource,
+    offline: offlineFrom(env) ?? false,
+    watched,
+    error,
+    notice,
+    missingUrl
+  };
+}
+function offlineFrom(env) {
+  const value = env.REYLO_OFFLINE?.trim().toLowerCase();
+  if (value === void 0 || value === "") return void 0;
+  return !(value === "0" || value === "false" || value === "no" || value === "off");
+}
+function offlineDialect(root) {
+  const declared = declaredEngines(packageDir(root));
+  if (declared.length === 1) return declared[0];
+  const entries = entryDialects(join(root, ".reylo", "queries"));
+  return entries.size === 1 ? [...entries][0] : void 0;
+}
+var DIALECTS = ["postgres", "sqlite", "mysql"];
+function declaredEngines(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    const listed2 = /* @__PURE__ */ new Set();
+    for (const key of ["dependencies", "devDependencies", "optionalDependencies"]) {
+      const group = Predicate.hasProperty(parsed, key) ? parsed[key] : void 0;
+      if (Predicate.isObject(group)) for (const name of Object.keys(group)) listed2.add(name);
+    }
+    return DIALECTS.filter((dialect) => listed2.has(ENGINE_PACKAGES[dialect]));
+  } catch {
+    return [];
+  }
+}
+var entryScans = /* @__PURE__ */ new Map();
+function entryDialects(dir) {
+  let mtime;
+  try {
+    mtime = statSync(dir).mtimeMs;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+  const cached = entryScans.get(dir);
+  if (cached?.mtime === mtime) return cached.dialects;
+  const dialects = /* @__PURE__ */ new Set();
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const parsed = JSON.parse(readFileSync(join(dir, name), "utf8"));
+      const found = Predicate.hasProperty(parsed, "dialect") ? parsed.dialect : void 0;
+      const dialect = DIALECTS.find((candidate) => candidate === found);
+      if (dialect !== void 0) dialects.add(dialect);
+    } catch {
+      continue;
+    }
+  }
+  entryScans.set(dir, { mtime, dialects });
+  return dialects;
+}
+function isSqlInputValue(value) {
+  return Predicate.isNull(value) || Predicate.isNumber(value) || Predicate.isBigInt(value) || Predicate.isString(value) || ArrayBuffer.isView(value);
+}
+function sqlitePath(url, baseDir) {
+  if (url === ":memory:" || url === "file::memory:") return ":memory:";
+  const raw = url.startsWith("file://") ? fileURLToPath(url) : url.replace(/^(file|sqlite):(\/\/)?/u, "");
+  return isAbsolute(raw) ? raw : resolve(baseDir, raw);
+}
+
+// src/reylo-session.ts
+import { createHash } from "node:crypto";
+import {
+  existsSync as existsSync3,
+  mkdirSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { join as join3 } from "node:path";
+import { Option as Option2, Schema as Schema2 } from "effect";
+
+// src/sqlite-drivers.ts
+import { fork } from "node:child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
+import { Option, Predicate as Predicate2, Schema } from "effect";
+function sync(name, database) {
+  const version = database.prepare("select sqlite_version() as v").get().v;
+  return {
+    name,
+    says: (refusal) => `${name} runs SQLite ${version}, which refuses this statement: ${refusal}`,
+    async refuses(sql) {
+      try {
+        database.prepare(sql);
+        return void 0;
+      } catch (cause) {
+        return cause instanceof Error ? cause.message : String(cause);
+      }
+    },
+    async close() {
+      database.close();
+    }
+  };
+}
+var DRIVERS = [
+  [
+    "better-sqlite3",
+    async (require2, path) => {
+      const Database = require2("better-sqlite3");
+      return sync("better-sqlite3", new Database(path, { readonly: true, fileMustExist: true }));
+    }
+  ],
+  [
+    // `@libsql/client` opens a file through the `libsql` package, its own dependency.
+    "@libsql/client",
+    async (require2, path) => {
+      const Database = createRequire2(require2.resolve("@libsql/client"))(
+        "libsql"
+      );
+      return sync("@libsql/client", new Database(path, { readonly: true }));
+    }
+  ],
+  [
+    "libsql",
+    async (require2, path) => {
+      const Database = require2("libsql");
+      return sync("libsql", new Database(path, { readonly: true }));
+    }
+  ],
+  ["sqlite3", openSqlite3],
+  [
+    "@tursodatabase/database",
+    async (require2, path) => {
+      const url = pathToFileURL2(require2.resolve("@tursodatabase/database/compat")).href;
+      const { Database } = await import(url);
+      return sync("@tursodatabase/database", new Database(path, { readonly: true }));
+    }
+  ],
+  ["wrangler", openD1]
+];
+async function openSqlite3(require2, path) {
+  const sqlite3 = require2("sqlite3");
+  const database = await new Promise((done, fail2) => {
+    const opened = new sqlite3.Database(
+      path,
+      sqlite3.OPEN_READONLY,
+      (error) => error ? fail2(error) : done(opened)
+    );
+  });
+  const version = await new Promise(
+    (done, fail2) => database.get(
+      "select sqlite_version() as v",
+      (error, row) => error ? fail2(error) : done(row.v)
+    )
+  );
+  return {
+    name: "sqlite3",
+    says: (refusal) => `sqlite3 runs SQLite ${version}, which refuses this statement: ${refusal}`,
+    refuses: (sql) => new Promise((done) => {
+      const statement = database.prepare(sql, (error) => {
+        if (!error) statement.finalize();
+        done(error ? error.message.replace(/^SQLITE_\w+: /u, "") : void 0);
+      });
+    }),
+    close: () => new Promise((done) => database.close(() => done()))
+  };
+}
+var D1_START = 3e4;
+var d1s = /* @__PURE__ */ new Map();
+function wranglerConfig(dir) {
+  return ["wrangler.json", "wrangler.jsonc", "wrangler.toml"].map((name) => {
+    try {
+      const { size, mtimeMs } = statSync2(join2(dir, name));
+      return `${name} ${size} ${mtimeMs}`;
+    } catch {
+      return "";
+    }
+  }).join("\0");
+}
+async function openD1(require2, path) {
+  const entry = require2.resolve("wrangler");
+  const dir = dirname2(require2.resolve("./package.json"));
+  const key = `${entry}\0${dir}`;
+  const config = wranglerConfig(dir);
+  let held = d1s.get(key);
+  if (held?.config !== config) {
+    held?.started.then(
+      (d12) => d12.close(),
+      () => void 0
+    );
+    const started = startD1(entry, dir, () => {
+      if (d1s.get(key)?.started === started) d1s.delete(key);
+    });
+    started.catch(() => {
+      if (d1s.get(key)?.started === started) d1s.delete(key);
+    });
+    held = { config, started };
+    d1s.set(key, held);
+  }
+  const d1 = await held.started;
+  const schema = new DatabaseSync(path, { readOnly: true });
+  return {
+    name: "wrangler",
+    says: (refusal) => `Cloudflare D1, as wrangler ${d1.version} runs it locally, refuses this statement: ${refusal}`,
+    async refuses(sql, params) {
+      let ddl;
+      try {
+        ddl = schemaDdl(schema);
+      } catch {
+        return void 0;
+      }
+      return d1.explain(sql, params, ddl);
+    },
+    async close() {
+      schema.close();
+    }
+  };
+}
+function schemaDdl(database) {
+  return database.prepare(
+    `select s.sql from sqlite_schema s where s.sql is not null and substr(s.name, 1, 7) <> 'sqlite_' and substr(s.name, 1, 4) <> '_cf_'
+         and not exists (select 1 from pragma_table_list p where p.name = s.name and p.type = 'shadow') order by s.rowid`
+  ).all().flatMap((row) => Predicate2.isString(row.sql) ? [row.sql] : []);
+}
+var ProxyMessage = Schema.Struct({
+  kind: Schema.optionalKey(Schema.String),
+  id: Schema.optionalKey(Schema.Number),
+  d1: Schema.optionalKey(Schema.Boolean),
+  error: Schema.optionalKey(Schema.String)
+});
+var decodeProxyMessage = Schema.decodeUnknownOption(ProxyMessage);
+var NO_MESSAGE = {};
+async function startD1(entry, dir, ended) {
+  const version = wranglerVersion(entry);
+  const engineDir = sqlitePackageDir(dir);
+  if (engineDir === void 0) throw new Error("@reylosql/sqlite is not installed");
+  const child = fork(join2(engineDir, "d1-proxy.js"), [entry, dir], {
+    stdio: ["ignore", "ignore", "ignore", "ipc"],
+    env: { ...process.env, WRANGLER_SEND_METRICS: "false" }
+  });
+  child.unref();
+  const pending = /* @__PURE__ */ new Map();
+  let next = 0;
+  let sent;
+  const gone = new Promise(
+    (_, fail2) => child.once("exit", () => fail2(new Error("D1's process ended")))
+  );
+  gone.catch(() => void 0);
+  child.on("message", (raw) => {
+    const message = Option.getOrElse(decodeProxyMessage(raw), () => NO_MESSAGE);
+    if (message.kind !== "explain" || message.id === void 0) return;
+    pending.get(message.id)?.(message.error);
+    pending.delete(message.id);
+    if (pending.size === 0) child.channel?.unref();
+  });
+  let running = false;
+  child.once("exit", () => {
+    if (running) ended();
+    for (const settle of pending.values()) settle(void 0);
+    pending.clear();
+  });
+  const stop = () => {
+    if (child.connected) child.send({ kind: "close" });
+    setTimeout(() => child.kill(), 2e3).unref();
+  };
+  try {
+    const timeout = new Promise(
+      (_, fail2) => setTimeout(() => fail2(new Error("workerd did not start")), D1_START).unref()
+    );
+    const ready = await Promise.race([
+      gone,
+      timeout,
+      // SAFETY: the D1 proxy's first message is `ready`.
+      new Promise(
+        (done) => child.once(
+          "message",
+          (raw) => done(Option.getOrElse(decodeProxyMessage(raw), () => NO_MESSAGE))
+        )
+      )
+    ]);
+    if (!ready.d1) throw new Error("the wrangler config binds no D1 database");
+  } catch (cause) {
+    stop();
+    throw cause;
+  }
+  running = true;
+  child.channel?.unref();
+  return {
+    version,
+    close: stop,
+    explain: (sql, params, ddl) => new Promise((done) => {
+      if (!child.connected) return done(void 0);
+      const id = next++;
+      pending.set(id, (error) => {
+        const message = error?.replace(/^D1_ERROR: /u, "").replace(/ at offset \d+/u, "").replace(/: SQLITE_\w+$/u, "");
+        done(
+          message && !message.startsWith("Wrong number of parameter bindings") ? message : void 0
+        );
+      });
+      child.channel?.ref();
+      const text = JSON.stringify(ddl);
+      if (text !== sent) {
+        child.send({ kind: "schema", ddl });
+        sent = text;
+      }
+      child.send({ kind: "explain", id, sql, params });
+    })
+  };
+}
+function wranglerVersion(entry) {
+  for (let dir = dirname2(entry); dirname2(dir) !== dir; dir = dirname2(dir)) {
+    const file = join2(dir, "package.json");
+    if (!existsSync2(file)) continue;
+    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    if (Predicate2.hasProperty(parsed, "name") && parsed.name === "wrangler")
+      return Predicate2.hasProperty(parsed, "version") && Predicate2.isString(parsed.version) ? parsed.version : "";
+  }
+  return "";
+}
+function projectDrivers(root) {
+  const file = join2(packageDir(root), "package.json");
+  if (!existsSync2(file)) return [];
+  const listed2 = /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    for (const key of ["dependencies", "devDependencies", "optionalDependencies"]) {
+      const group = Predicate2.hasProperty(parsed, key) ? parsed[key] : void 0;
+      if (Predicate2.isObject(group)) for (const name of Object.keys(group)) listed2.add(name);
+    }
+  } catch {
+    return [];
+  }
+  return DRIVERS.flatMap(([name]) => listed2.has(name) ? [name] : []);
+}
+async function openProjectDrivers(root, path) {
+  if (path === ":memory:") return [];
+  const names = projectDrivers(root);
+  if (names.length === 0) return [];
+  const require2 = createRequire2(join2(packageDir(root), "package.json"));
+  const opened = await Promise.all(
+    DRIVERS.flatMap(
+      ([name, open]) => names.includes(name) ? [open(require2, path).catch(() => void 0)] : []
+    )
+  );
+  return opened.filter((driver) => driver !== void 0);
+}
+var utf8 = new TextEncoder();
+function placeRefusal(sql, message) {
+  const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  const fn = /(?:no such function|not authorized to use function): ([\w$]+)/iu.exec(message)?.[1] ?? /arguments to function ([\w$]+)\(\)/iu.exec(message)?.[1];
+  const near = /near "([^"]+)"/u.exec(message)?.[1];
+  const found = fn ? new RegExp(`\\b${escape(fn)}\\s*\\(`, "iu").exec(sql) : near ? new RegExp(escape(near), "iu").exec(sql) : null;
+  const at = found ? { index: found.index, text: fn ?? near ?? "" } : { index: sql.search(/\S/u), text: /\S+/u.exec(sql)?.[0] ?? "" };
+  return {
+    start: utf8.encode(sql.slice(0, Math.max(at.index, 0))).length,
+    length: Math.max(utf8.encode(at.text).length, 1)
+  };
+}
+
+// src/reylo-session.ts
+var ENTRY_VERSION = 1;
+var OFFLINE = "Cache-only analysis (REYLO_OFFLINE or offline in .reylo.yaml) opens no database connection";
+var OFFLINE_MISS = `${OFFLINE}, and .reylo has no analysis of this statement: analyze it where the analysis database can be reached (reylo generate, a build, or a test run in CI) and deploy .reylo with the application.`;
+var SCHEMA_TTL = 5e3;
+var OFFLINE_TTL = 6e4;
+var NativeSession = class {
+  project;
+  #engine;
+  #engineFingerprint;
+  #answers = new AnswerCache();
+  #idle;
+  #io;
+  #busy = 0;
+  #timer;
+  #schema;
+  constructor(engine2, project, idle) {
+    this.#engine = engine2;
+    this.project = project;
+    this.#idle = idle;
+    const ping = engine2 instanceof MissingEngine ? void 0 : engine2.call({ op: "ping" });
+    this.#engineFingerprint = ping?.status === "ok" ? ping.fingerprint : "unknown";
+  }
+  lex(sql) {
+    if (this.#engine instanceof MissingEngine) throw this.#engine;
+    return this.#engine.lex(sql, this.project.dialect);
+  }
+  /** Named by the statement, then by the server, so a dev and a test database keep one each. */
+  entryFile(sql) {
+    return join3(
+      this.project.root,
+      ".reylo",
+      "queries",
+      `${this.#statementKey(sql)}-${sha256(this.#server()).slice(0, 16)}.json`
+    );
+  }
+  #statementKey(sql) {
+    return sha256(
+      JSON.stringify([ENTRY_VERSION, this.#engineFingerprint, this.project.dialect, sql])
+    ).slice(0, 32);
+  }
+  /** This server's entry for the statement, else the newest any other server wrote. */
+  #offlineEntry(sql) {
+    const own = this.entryFile(sql);
+    const entry = readEntry(own);
+    if (entry) return { file: own, entry };
+    const dir = join3(this.project.root, ".reylo", "queries");
+    const prefix = `${this.#statementKey(sql)}-`;
+    let names;
+    try {
+      names = readdirSync2(dir).filter((name) => name.startsWith(prefix) && name.endsWith(".json"));
+    } catch {
+      return void 0;
+    }
+    let newest;
+    for (const file of names.map((name) => join3(dir, name))) {
+      const other = readEntry(file);
+      if (other && (!newest || (other.at ?? -Infinity) > (newest.entry.at ?? -Infinity)))
+        newest = { file, entry: other };
+    }
+    return newest;
+  }
+  async analyze(sql) {
+    clearTimeout(this.#timer);
+    this.#busy++;
+    try {
+      const outcome = await this.#analyze(sql);
+      return outcome.ok && this.project.dialect === "sqlite" ? await this.#onDrivers(sql, outcome) : outcome;
+    } finally {
+      if (--this.#busy === 0 && this.#io && Number.isFinite(this.#idle))
+        this.#timer = setTimeout(() => void this.#release(), this.#idle).unref();
+    }
+  }
+  /** A SQLite statement prepared on the app's own drivers too, whose SQLite may be older. */
+  async #onDrivers(sql, outcome) {
+    const { analysis } = outcome;
+    if (analysis.diagnostics.length > 0 || this.#schema?.value == null) return outcome;
+    const io = await this.#connection().catch(() => void 0);
+    const drivers = await io?.drivers?.() ?? [];
+    for (const driver of drivers) {
+      const refusal = await driver.refuses(analysis.rewritten.sql, analysis.rewritten.order.length);
+      if (refusal === void 0) continue;
+      const { start, length } = placeRefusal(sql, refusal);
+      return {
+        ...outcome,
+        analysis: {
+          ...analysis,
+          diagnostics: [{ message: driver.says(refusal), start, length, code: 6 }]
+        }
+      };
+    }
+    return outcome;
+  }
+  async #analyze(sql) {
+    if (this.project.error) return { ok: false, message: this.project.error, code: 11 };
+    if (this.project.offline) {
+      const engine3 = this.#engine;
+      if (engine3 instanceof MissingEngine) return { ok: false, message: engine3.message, code: 11 };
+      const hit = this.#offlineEntry(sql);
+      return hit ? { ok: true, analysis: hit.entry.analysis, source: "cache", entry: hit.file } : { ok: false, message: OFFLINE_MISS, code: 4 };
+    }
+    if (!this.project.url) {
+      const hit = this.#engine instanceof MissingEngine ? void 0 : this.#offlineEntry(sql);
+      return hit ? { ok: true, analysis: hit.entry.analysis, source: "cache", entry: hit.file } : { ok: false, message: this.project.missingUrl, code: 4 };
+    }
+    const engine2 = this.#engine;
+    if (engine2 instanceof MissingEngine) return { ok: false, message: engine2.message, code: 11 };
+    const file = this.entryFile(sql);
+    const schema = await this.schema();
+    if (schema.fatal) return { ok: false, message: schema.error ?? "Cannot load schema", code: 5 };
+    if (schema.value === null) {
+      const hit = this.#offlineEntry(sql);
+      if (hit) return { ok: true, analysis: hit.entry.analysis, source: "cache", entry: hit.file };
+      return {
+        ok: false,
+        message: `${this.cannotConnect(schema.error)}; .reylo has no analysis of this statement, so run reylo generate where the database can be reached.`,
+        code: 5
+      };
+    }
+    const entry = readEntry(file);
+    if (entry && entry.schema === schema.value)
+      return { ok: true, analysis: entry.analysis, source: "cache", entry: file };
+    let analysis;
+    try {
+      analysis = await engine2.analyze(
+        sql,
+        this.project.dialect,
+        await this.#connection(),
+        this.#answers
+      );
+    } catch (cause) {
+      if (cause instanceof Error && isUnreachable(cause)) {
+        this.#io = void 0;
+        this.#schema = { value: null, at: Date.now(), error: reason(cause) };
+        return { ok: false, message: this.cannotConnect(reason(cause)), code: 5 };
+      }
+      if (cause instanceof Error && isNotMysql(cause)) {
+        const error = this.notMysql(cause);
+        this.#io = void 0;
+        this.#schema = { value: null, at: Date.now(), error, fatal: true };
+        return { ok: false, message: error, code: 5 };
+      }
+      return { ok: false, message: reason(cause), code: 5 };
+    }
+    writeEntry(this.project.root, file, {
+      version: ENTRY_VERSION,
+      dialect: this.project.dialect,
+      schema: schema.value,
+      analysis,
+      at: Date.now()
+    });
+    return { ok: true, analysis, source: "database", entry: file };
+  }
+  /** A server that refuses the fingerprint query gets a value no entry matches: analysis goes live. */
+  async schema() {
+    const now = Date.now();
+    if (this.project.offline) return this.#schema ??= { value: null, at: now, error: OFFLINE };
+    if (this.#schema && now - this.#schema.at < (this.#schema.value === null ? OFFLINE_TTL : SCHEMA_TTL))
+      return this.#schema;
+    let io;
+    try {
+      io = await this.#connection();
+    } catch (cause) {
+      this.#io = void 0;
+      this.#schema = cause instanceof Error && isUnreachable(cause) ? { value: null, at: now, error: reason(cause) } : {
+        value: null,
+        at: now,
+        error: cause instanceof Error && isNotMysql(cause) ? this.notMysql(cause) : reason(cause),
+        fatal: true
+      };
+      return this.#schema;
+    }
+    try {
+      const rows = await io.query(FINGERPRINT[this.project.dialect], []);
+      const value = sha256(JSON.stringify(rows)).slice(0, 16);
+      if (this.#schema?.value && this.#schema.value !== value) this.#answers.clear();
+      this.#schema = { value, at: now };
+    } catch (cause) {
+      if (cause instanceof Error && isUnreachable(cause)) {
+        this.#io = void 0;
+        this.#schema = { value: null, at: now, error: reason(cause) };
+      } else {
+        this.#schema = { value: `unverified ${process.pid} ${now}`, at: now };
+      }
+    }
+    return this.#schema;
+  }
+  /** Reads the fingerprint again now, however recent the last read; whether it changed. */
+  async recheck() {
+    const before = this.#schema?.value;
+    if (this.#schema) this.#schema = { ...this.#schema, at: -Infinity };
+    return (await this.schema()).value !== before;
+  }
+  /** Where the database was looked for, and where that came from; never the credentials. */
+  cannotConnect(why) {
+    const { dialect, url, root, urlSource } = this.project;
+    const detail = why ? `: ${why}` : "";
+    if (dialect === "sqlite")
+      return `Cannot open the database ${sqlitePath(url ?? "", root)} (${urlSource})${detail}`;
+    return `Cannot connect to the database at ${this.where()} (${urlSource})${detail}`;
+  }
+  notMysql(cause) {
+    return `Cannot type-check against the database at ${this.where()} (${this.project.urlSource}): it is ${cause.server}, and Reylo type-checks MySQL statements against MySQL. Point the type check's URL at a MySQL server, 8.4 or later, with the same schema.`;
+  }
+  /** The server, without credentials, that names this session's entries. */
+  #server() {
+    const { dialect, url, root } = this.project;
+    if (!url) return "";
+    if (dialect === "sqlite") return sqlitePath(url, root);
+    try {
+      const parsed = new URL(url);
+      return `${parsed.protocol}//${parsed.username}@${parsed.host}${parsed.pathname}`;
+    } catch {
+      return url;
+    }
+  }
+  /** The database as a person names it: host, port and database, or the SQLite file. */
+  where() {
+    const { dialect, url, root } = this.project;
+    if (dialect === "sqlite") return sqlitePath(url ?? "", root);
+    try {
+      const parsed = new URL(url ?? "");
+      const host2 = parsed.hostname || parsed.searchParams.get("host") || "localhost";
+      return `${host2}${parsed.port ? `:${parsed.port}` : ""}${parsed.pathname}`;
+    } catch {
+      return "the database";
+    }
+  }
+  async close() {
+    await this.release();
+  }
+  /** Closes the connection now; the next analysis opens another. */
+  async release() {
+    clearTimeout(this.#timer);
+    await this.#release();
+  }
+  async #release() {
+    const io = this.#io;
+    this.#io = void 0;
+    if (io) await io.then((open) => open.close()).catch(() => void 0);
+  }
+  #connection() {
+    this.#io ??= openConnection(this.project);
+    const io = this.#io;
+    io.catch(() => {
+      if (this.#io === io) this.#io = void 0;
+    });
+    return io;
+  }
+};
+async function openConnection(project) {
+  const { dialect, url, root } = project;
+  if (dialect === "sqlite") {
+    const path = sqlitePath(url ?? "", root);
+    const database = await openSqlite(path).catch((cause) => Promise.reject(new Unreachable(cause)));
+    let drivers;
+    return {
+      describe: () => Promise.reject(new Error("SQLite is described inside the engine")),
+      query: (sql, params) => database.values(sql, params),
+      async close() {
+        const opened = await drivers ?? [];
+        await Promise.all(opened.map((driver) => driver.close().catch(() => void 0)));
+        database.close();
+      },
+      drivers: () => drivers ??= openProjectDrivers(root, path)
+    };
+  }
+  const loaded = await describer(dialect, root);
+  const open = dialect === "mysql" ? loaded.openMysqlDescriber : loaded.openPostgresDescriber;
+  if (open === void 0) throw MissingEngine.of(dialect);
+  const described = await open(url);
+  return {
+    describe: (sql) => described.describe(sql),
+    query: (sql, params) => described.values(sql, params),
+    close: () => described.close()
+  };
+}
+async function openSqlite(path) {
+  const { DatabaseSync: DatabaseSync3 } = await import("node:sqlite");
+  const database = new DatabaseSync3(path, { readOnly: path !== ":memory:" });
+  return {
+    async values(sql, params) {
+      if (!params.every(isSqlInputValue)) {
+        throw new Error(`SQLite cannot bind a catalog query parameter: ${sql}`);
+      }
+      const statement = database.prepare(sql);
+      statement.setReturnArrays(true);
+      return statement.all(...params).map((row) => Object.values(row));
+    },
+    close: () => database.close()
+  };
+}
+var sha256 = (text) => createHash("sha256").update(text).digest("hex");
+var StoredEntry = Schema2.fromJsonString(
+  Schema2.Struct({
+    version: Schema2.Literal(ENTRY_VERSION),
+    dialect: Schema2.Literals(["postgres", "sqlite", "mysql"]),
+    schema: Schema2.String,
+    analysis: Schema2.Record(Schema2.String, Schema2.Unknown),
+    at: Schema2.optionalKey(Schema2.Number)
+  })
+);
+var decodeEntry = Schema2.decodeUnknownOption(StoredEntry);
+function readEntry(file) {
+  if (!existsSync3(file)) return void 0;
+  let text;
+  try {
+    text = readFileSync3(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  const entry = decodeEntry(text);
+  if (Option2.isNone(entry)) return void 0;
+  return { ...entry.value, analysis: entry.value.analysis };
+}
+function writeEntry(root, file, entry) {
+  const dir = join3(root, ".reylo");
+  const temporary = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    mkdirSync(join3(dir, "queries"), { recursive: true });
+    const ignore = join3(dir, ".gitignore");
+    if (!existsSync3(ignore))
+      writeFileSync(
+        ignore,
+        "# reylo's cache: written by the type check, the build steps and reylo generate; never committed.\n*\n"
+      );
+    writeFileSync(temporary, `${JSON.stringify(entry)}
+`);
+    renameSync(temporary, file);
+  } catch {
+    rmSync(temporary, { force: true });
+  }
+}
+var NS = `not in ('pg_catalog', 'information_schema') and n.nspname !~ '^pg_(toast|temp)'`;
+var FINGERPRINT = {
+  postgres: `select md5(coalesce(string_agg(x, E'\\n' order by x), '')) from (
+    select 'v ' || current_setting('server_version_num') || ' ' || current_setting('search_path') as x
+    union all select 'r ' || c.oid || ' ' || n.nspname || '.' || c.relname || ' ' || c.relkind::text from pg_class c join pg_namespace n on n.oid = c.relnamespace where n.nspname ${NS}
+    union all select 'a ' || a.attrelid || ' ' || a.attnum || ' ' || a.attname || ' ' || a.atttypid || ' ' || a.attnotnull || ' ' || a.attcollation from pg_attribute a join pg_class c on c.oid = a.attrelid join pg_namespace n on n.oid = c.relnamespace where a.attnum > 0 and not a.attisdropped and n.nspname ${NS}
+    union all select 'h ' || h.inhrelid || ' ' || h.inhparent || ' ' || h.inhseqno from pg_inherits h join pg_class c on c.oid = h.inhrelid join pg_namespace n on n.oid = c.relnamespace where n.nspname ${NS}
+    union all select 'c ' || o.conrelid || ' ' || o.contypid || ' ' || o.conname || ' ' || pg_get_constraintdef(o.oid) from pg_constraint o join pg_namespace n on n.oid = o.connamespace where n.nspname ${NS}
+    union all select 'i ' || i.indexrelid || ' ' || i.indisvalid || ' ' || pg_get_indexdef(i.indexrelid) from pg_index i join pg_class c on c.oid = i.indrelid join pg_namespace n on n.oid = c.relnamespace where n.nspname ${NS}
+    union all select 'g ' || g.tgrelid || ' ' || g.tgname || ' ' || g.tgtype || ' ' || g.tgenabled::text from pg_trigger g join pg_class c on c.oid = g.tgrelid join pg_namespace n on n.oid = c.relnamespace where not g.tgisinternal and n.nspname ${NS}
+    union all select 'u ' || w.ev_class || ' ' || w.rulename || ' ' || w.ev_type::text || ' ' || w.ev_enabled::text || ' ' || md5(pg_get_ruledef(w.oid)) from pg_rewrite w join pg_class c on c.oid = w.ev_class join pg_namespace n on n.oid = c.relnamespace where w.rulename <> '_RETURN' and n.nspname ${NS}
+    union all select 'o ' || o.oid || ' ' || o.oprname || ' ' || o.oprleft || ' ' || o.oprright || ' ' || o.oprcode::oid from pg_operator o where o.oid >= 16384
+    union all select 'e ' || e.enumtypid || ' ' || e.enumsortorder || ' ' || e.enumlabel from pg_enum e
+    union all select 't ' || t.oid || ' ' || t.typname || ' ' || t.typtype::text || ' ' || t.typbasetype || ' ' || t.typnotnull from pg_type t join pg_namespace n on n.oid = t.typnamespace where n.nspname ${NS}
+    union all select 'f ' || p.oid || ' ' || p.proname || ' ' || p.prorettype || ' ' || p.proretset || ' ' || p.proargtypes::text || ' ' || md5(coalesce(p.prosrc, '')) from pg_proc p join pg_namespace n on n.oid = p.pronamespace where n.nspname ${NS}
+    union all select 'w ' || c.oid || ' ' || md5(pg_get_viewdef(c.oid)) from pg_class c join pg_namespace n on n.oid = c.relnamespace where c.relkind in ('v', 'm') and n.nspname ${NS}
+    union all select 'd ' || d.objoid || ' ' || d.objsubid || ' ' || md5(d.description) from pg_description d join pg_class c on c.oid = d.objoid join pg_namespace n on n.oid = c.relnamespace where d.classoid = 'pg_class'::regclass and d.objsubid > 0 and n.nspname ${NS}
+  ) t`,
+  mysql: `select concat_ws(' ', @@version, @@sql_mode, count(*), sum(crc32(x)), bit_xor(crc32(x))) from (
+    select concat_ws(' ', 'c', table_name, column_name, ordinal_position, column_type, is_nullable, column_key, extra, coalesce(generation_expression, ''), md5(column_comment)) as x from information_schema.columns where table_schema = database()
+    union all select concat_ws(' ', 's', table_name, index_name, non_unique, seq_in_index, column_name) from information_schema.statistics where table_schema = database()
+    union all select concat_ws(' ', 'v', table_name, md5(view_definition)) from information_schema.views where table_schema = database()
+    union all select concat_ws(' ', 'r', routine_name, routine_type, coalesce(dtd_identifier, ''), md5(coalesce(routine_definition, ''))) from information_schema.routines where routine_schema = database()
+  ) t`,
+  sqlite: `select type, name, tbl_name, coalesce(sql, '') from sqlite_schema
+    union all select 'function', name, type, narg from pragma_function_list order by 1, 2, 3, 4`
+};
+
+// src/schema-files.ts
+import { createHash as createHash2 } from "node:crypto";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { Effect as Effect2, FileSystem, Path, Semaphore } from "effect";
+
+// src/schema-postgres.ts
+import { createRequire as createRequire3 } from "node:module";
+import { join as join4 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
+import {
+  messages as pgMessages,
+  PGlite
+} from "@electric-sql/pglite";
+import { Effect, Option as Option3, Predicate as Predicate3, Schema as Schema3 } from "effect";
+
+// src/sql-tokens.ts
+function* sqlTokens(sql, dialect = "sqlite", comments = false) {
+  for (let index = 0; index < sql.length; ) {
+    const start = index;
+    const ch = sql[index];
+    if (/\s/u.test(ch)) {
+      index++;
+      continue;
+    }
+    if (sql.startsWith("--", index) && (dialect !== "mysql" || /\s/u.test(sql[index + 2] ?? "\n")) || dialect === "mysql" && ch === "#") {
+      const end = sql.indexOf("\n", index);
+      index = end < 0 ? sql.length : end + 1;
+      if (comments) yield { kind: "comment", text: sql.slice(start, index), start, end: index };
+      continue;
+    }
+    if (sql.startsWith("/*", index)) {
+      const executable = dialect === "mysql" && sql[index + 2] === "!";
+      let depth = 1;
+      index += 2;
+      while (index < sql.length && depth > 0) {
+        if (dialect === "postgres" && sql.startsWith("/*", index)) {
+          depth++;
+          index += 2;
+        } else if (sql.startsWith("*/", index)) {
+          depth--;
+          index += 2;
+        } else index++;
+      }
+      if (comments) yield { kind: "comment", text: sql.slice(start, index), start, end: index };
+      else if (executable) {
+        const prefix = /^\/\*!\d*\s*/u.exec(sql.slice(start))[0].length;
+        const offset = start + prefix;
+        const body = sql.slice(offset, depth === 0 ? index - 2 : index);
+        for (const token of sqlTokens(body, dialect)) {
+          yield { ...token, start: token.start + offset, end: token.end + offset };
+        }
+      }
+      continue;
+    }
+    const escaped = dialect === "postgres" && /^[eE]'/.test(sql.slice(index, index + 2));
+    const quote = escaped ? "'" : ch;
+    if (quote === "'" || quote === '"' || quote === "`" || dialect === "sqlite" && quote === "[") {
+      const close = quote === "[" ? "]" : quote;
+      const backslash = escaped || dialect === "mysql" && quote !== "`";
+      index += escaped ? 2 : 1;
+      while (index < sql.length) {
+        if (backslash && sql[index] === "\\") index += 2;
+        else if (sql[index++] === close) {
+          if (quote !== "[" && sql[index] === close) index++;
+          else break;
+        }
+      }
+      yield { kind: "quoted", text: sql.slice(start, index), start, end: index };
+      continue;
+    }
+    if (ch === "$" && dialect !== "mysql") {
+      const tag = /^\$(?:[A-Za-z_][\w]*)?\$/u.exec(sql.slice(index))?.[0];
+      if (tag !== void 0) {
+        const end = sql.indexOf(tag, index + tag.length);
+        index = end < 0 ? sql.length : end + tag.length;
+        yield { kind: "quoted", text: sql.slice(start, index), start, end: index };
+        continue;
+      }
+    }
+    if (/[A-Za-z_]/u.test(ch)) {
+      while (/[\w$]/u.test(sql[++index] ?? "")) {
+      }
+      yield { kind: "word", text: sql.slice(start, index), start, end: index };
+    } else {
+      index++;
+      yield { kind: "symbol", text: ch, start, end: index };
+    }
+  }
+}
+
+// src/split-sql.ts
+var STATEMENT_START = /^(?:select|insert|update|delete|replace|with|end)\b/iu;
+var COMPOUND_END = /* @__PURE__ */ new Set(["IF", "LOOP", "WHILE", "REPEAT", "FOREACH", "CASE"]);
+function splitSql(sql, dialect = "sqlite") {
+  const statements = [];
+  const tokens2 = [...sqlTokens(sql, dialect)];
+  let start = 0;
+  let hasSql = false;
+  let caseDepth = 0;
+  let mode = "sql";
+  let body = 0;
+  let routineDepth = 0;
+  let statementStart = true;
+  for (const [index, token] of tokens2.entries()) {
+    if (token.kind === "symbol" && token.text === ";") {
+      if (body === 0 && routineDepth === 0 && caseDepth === 0) {
+        if (hasSql) statements.push(sql.slice(start, token.start).trim());
+        start = token.end;
+        hasSql = false;
+        mode = "sql";
+      }
+      statementStart = true;
+      continue;
+    }
+    hasSql = true;
+    const initial = statementStart;
+    statementStart = false;
+    if (token.kind !== "word") continue;
+    const upper = token.text.toUpperCase();
+    const next = tokens2[index + 1];
+    const nextWord = next?.kind === "word" ? next.text.toUpperCase() : "";
+    if (mode === "routine") {
+      if (upper === "CASE" && (!initial || caseDepth > 0) && tokens2[index - 1]?.text.toUpperCase() !== "END") {
+        caseDepth++;
+      } else if (upper === "END" && caseDepth > 0) {
+        caseDepth--;
+        continue;
+      }
+      if (caseDepth === 0 && ["THEN", "ELSE", "DO", "LOOP", "REPEAT"].includes(upper)) {
+        statementStart = true;
+      }
+      if (upper === "BEGIN" && (routineDepth === 0 || initial)) {
+        routineDepth++;
+        statementStart = true;
+      } else if (upper === "END" && routineDepth > 0 && initial && !COMPOUND_END.has(nextWord)) {
+        routineDepth--;
+      }
+    } else if (upper === "CASE") caseDepth++;
+    else if (upper === "END") {
+      if (caseDepth > 0) caseDepth--;
+      else if (body > 0 && initial) body = 0;
+    } else if (upper === "BEGIN" && mode === "trigger" && STATEMENT_START.test(nextWord)) {
+      body = 1;
+      statementStart = true;
+    } else if (initial && upper === "CREATE") mode = "create";
+    else if (mode === "create") {
+      if (upper === "TRIGGER") mode = dialect === "mysql" ? "routine" : "trigger";
+      else if (upper === "PROCEDURE" || upper === "FUNCTION") mode = "routine";
+      else if (upper !== "TEMP" && upper !== "TEMPORARY" && upper !== "OR" && upper !== "REPLACE")
+        mode = "sql";
+    }
+  }
+  if (hasSql) statements.push(sql.slice(start).trim());
+  return statements;
+}
+
+// src/schema-postgres.ts
+var SchemaLoadError = class _SchemaLoadError extends Schema3.TaggedError("reylo-effect/SchemaLoadError")("SchemaLoadError", {
+  message: Schema3.String,
+  cause: Schema3.optionalKey(Schema3.Defect())
+}) {
+  static forFile(file, cause) {
+    return new _SchemaLoadError({
+      message: `Cannot load the schema: ${file}: ${describeCause(cause)}`,
+      cause
+    });
+  }
+};
+function describeCause(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+var MissingRole = class extends Schema3.TaggedError(
+  "reylo-effect/MissingRole"
+)("MissingRole", {
+  role: Schema3.String,
+  file: Schema3.String,
+  cause: Schema3.Defect()
+}) {
+};
+var MAX_ROLES = 64;
+var describePostgres = Effect.fn("SchemaPostgres.describe")(function* (database, sql, parameterTypes = []) {
+  const text = Buffer.from(sql);
+  const parse2 = Buffer.alloc(text.length + 9 + parameterTypes.length * 4);
+  parse2[0] = 80;
+  parse2.writeInt32BE(parse2.length - 1, 1);
+  text.copy(parse2, 6);
+  parse2.writeUInt16BE(parameterTypes.length, text.length + 7);
+  parameterTypes.forEach((oid, index) => parse2.writeUInt32BE(oid, text.length + 9 + index * 4));
+  const describe = Buffer.from([68, 0, 0, 0, 6, 83, 0]);
+  const sync2 = Buffer.from([83, 0, 0, 0, 4]);
+  const { messages } = yield* Effect.promise(
+    () => database.execProtocol(Buffer.concat([parse2, describe, sync2]), { throwOnError: false })
+  );
+  const result = { params: [], columns: [] };
+  for (const message of messages) {
+    if (message.name === "error") return yield* Effect.fail(message);
+    if (message instanceof pgMessages.ParameterDescriptionMessage) {
+      result.params = message.dataTypeIDs.map((oid) => ({ oid }));
+    }
+    if (message instanceof pgMessages.RowDescriptionMessage) {
+      result.columns = message.fields.map((field) => ({
+        name: field.name,
+        oid: field.dataTypeID,
+        table: field.tableID,
+        attnum: field.columnID
+      }));
+    }
+  }
+  return result;
+});
+var loadPostgresSchema = (texts, root) => Effect.flatMap(
+  extensionsOf(texts, root),
+  (extensions) => openWithRoles(texts, extensions, /* @__PURE__ */ new Set())
+);
+var openWithRoles = (texts, extensions, roles) => Effect.gen(function* () {
+  const database = yield* Effect.promise(() => PGlite.create({ extensions }));
+  const close = Effect.promise(() => database.close());
+  yield* Effect.onError(populate(database, texts, roles), () => close);
+  yield* Effect.addFinalizer(() => close);
+  return database;
+}).pipe(
+  Effect.catchTag(
+    "MissingRole",
+    (missing) => roles.has(missing.role) || roles.size >= MAX_ROLES ? SchemaLoadError.forFile(missing.file, missing.cause) : openWithRoles(texts, extensions, /* @__PURE__ */ new Set([...roles, missing.role]))
+  )
+);
+var populate = Effect.fn("SchemaPostgres.populate")(function* (database, texts, roles) {
+  for (const role of roles) {
+    yield* run(database, `create role "${role.replaceAll('"', '""')}" superuser`, "schema");
+  }
+  for (const source of texts) {
+    yield* run(database, source.text, source.file);
+    yield* run(database, "reset all; set session authorization default", source.file);
+  }
+});
+var run = (database, sql, file) => Effect.tryPromise({
+  try: () => database.exec(sql),
+  catch: (cause) => {
+    const missing = /^role "(.+)" does not exist$/u.exec(describeCause(cause))?.[1];
+    return missing === void 0 ? SchemaLoadError.forFile(file, cause) : new MissingRole({ role: missing, file, cause });
+  }
+});
+var extensionsOf = Effect.fn("SchemaPostgres.extensions")(function* (texts, root) {
+  const extensions = {};
+  const require2 = createRequire3(join4(root, "package.json"));
+  for (const { text } of texts) {
+    for (const statement of splitSql(text, "postgres")) {
+      const key = extensionKey(statement);
+      if (key === void 0) continue;
+      const specifier = key === "vector" ? "@electric-sql/pglite-pgvector" : `@electric-sql/pglite/contrib/${key}`;
+      const path = Option3.orElse(
+        resolveFrom2(require2, specifier),
+        () => resolveFrom2(createRequire3(import.meta.url), specifier)
+      );
+      if (Option3.isNone(path)) continue;
+      const loaded = yield* Effect.promise(() => import(pathToFileURL3(path.value).href));
+      const extension = Predicate3.isReadonlyObject(loaded) ? loaded[key] : void 0;
+      if (isExtension(extension)) extensions[key] = extension;
+    }
+  }
+  return extensions;
+});
+function extensionKey(statement) {
+  const tokens2 = [...sqlTokens(statement, "postgres")];
+  if (tokens2[0]?.text.toLowerCase() !== "create" || tokens2[1]?.text.toLowerCase() !== "extension")
+    return void 0;
+  const raw = tokens2[tokens2[2]?.text.toLowerCase() === "if" ? 5 : 2]?.text;
+  if (raw === void 0) return void 0;
+  const name = raw.startsWith('"') ? raw.slice(1, -1).replaceAll('""', '"') : raw.toLowerCase();
+  return name.replaceAll("-", "_");
+}
+function resolveFrom2(require2, specifier) {
+  return Option3.liftThrowable(() => require2.resolve(specifier))();
+}
+function isExtension(value) {
+  return Predicate3.isReadonlyObject(value) && Predicate3.isString(value.name) && Predicate3.isFunction(value.setup);
+}
+
+// src/schema-files.ts
+var GLOB = /[*?[\]{}()\\]|^!/u;
+var schemaFiles = Effect2.fn("SchemaFiles.find")(function* (root, patterns) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const files = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const glob = GLOB.test(pattern);
+    const paths = glob ? (yield* fs.glob(pattern, { root, exclude: ["**/node_modules/**"] })).map(
+      (name) => path.resolve(root, name)
+    ) : [path.resolve(root, pattern)];
+    const found = (yield* Effect2.filter(paths, (candidate) => isSchemaFile(fs, candidate))).sort(
+      (a, b) => natural(path.relative(root, a), path.relative(root, b))
+    );
+    if (found.length === 0) {
+      return {
+        files: [...files],
+        error: `"schema" in .reylo.yaml names ${pattern}, which ${glob ? "matches no file" : "does not exist"}`
+      };
+    }
+    for (const file of found) files.add(file);
+  }
+  return { files: [...files] };
+});
+function isSchemaFile(fs, candidate) {
+  if (/\.down\.sql$/iu.test(candidate)) return Effect2.succeed(false);
+  return fs.stat(candidate).pipe(
+    Effect2.map((info) => info.type === "File"),
+    Effect2.orElseSucceed(() => false)
+  );
+}
+function natural(left, right) {
+  const a = left.match(/\d+|\D+/gu) ?? [];
+  const b = right.match(/\d+|\D+/gu) ?? [];
+  for (let index = 0; index < Math.min(a.length, b.length); index++) {
+    const x = a[index];
+    const y = b[index];
+    if (x === y) continue;
+    if (/^\d/u.test(x) && /^\d/u.test(y)) {
+      const delta = BigInt(x) - BigInt(y);
+      if (delta !== 0n) return delta < 0n ? -1 : 1;
+    } else return x < y ? -1 : 1;
+  }
+  return a.length - b.length;
+}
+var schemaFingerprint = Effect2.fn("SchemaFiles.fingerprint")(function* (root, files, dialect) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const hash = createHash2("sha256").update(
+    JSON.stringify(["schema-text/2", dialect, process.versions.sqlite, "pglite/0.5.11"])
+  );
+  for (const file of files) {
+    hash.update(path.relative(root, file)).update("\0").update(yield* fs.readFile(file)).update("\0");
+  }
+  return hash.digest("hex");
+});
+var openSchemaDatabase = (dialect, files, root) => Effect2.gen(function* () {
+  if (dialect === "mysql") {
+    return yield* new SchemaLoadError({
+      message: '"schema" loads a Postgres or SQLite schema; MySQL needs a MySQL 8.4 server. Remove schema and set direct_url or DATABASE_URL.'
+    });
+  }
+  const fs = yield* FileSystem.FileSystem;
+  const texts = yield* Effect2.forEach(
+    files,
+    (file) => Effect2.map(fs.readFileString(file), (text) => ({
+      file,
+      text: schemaText(text, dialect)
+    }))
+  );
+  if (dialect === "sqlite") return yield* openSqlite2(texts);
+  const database = yield* loadPostgresSchema(texts, root);
+  const session = yield* Semaphore.make(1);
+  const serial = session.withPermits(1);
+  const runPromise = Effect2.runPromiseWith(yield* Effect2.context());
+  return {
+    describe: (sql) => runPromise(serial(describePostgres(database, sql))),
+    describeParameters: (sql, parameterTypes) => runPromise(serial(describePostgres(database, sql, parameterTypes))),
+    query: (sql, params) => runPromise(
+      serial(
+        Effect2.promise(async () => {
+          const result = await database.query(sql, params, {
+            rowMode: "array",
+            parsers: { 20: (text) => text }
+          });
+          return result.rows;
+        })
+      )
+    )
+  };
+});
+var openSqlite2 = Effect2.fn("SchemaFiles.openSqlite")(function* (texts) {
+  const database = yield* Effect2.acquireRelease(
+    Effect2.sync(() => new DatabaseSync2(":memory:")),
+    (open) => Effect2.sync(() => open.close())
+  );
+  for (const { file, text } of texts) {
+    yield* Effect2.try({
+      try: () => database.exec(text),
+      catch: (cause) => SchemaLoadError.forFile(file, cause)
+    });
+  }
+  return {
+    async describe() {
+      throw new Error("The engine describes SQLite internally");
+    },
+    async query(sql, params) {
+      if (!params.every(isSqlInputValue)) {
+        throw new Error(`SQLite cannot bind a catalog query parameter: ${sql}`);
+      }
+      const statement = database.prepare(sql);
+      statement.setReturnArrays(true);
+      return statement.all(...params).map((row) => Object.values(row));
+    }
+  };
+});
+function schemaText(text, dialect) {
+  const tokens2 = [...sqlTokens(text, dialect, true)];
+  const down = tokens2.find(
+    (token) => token.kind === "comment" && /^[ \t]*$/u.test(text.slice(text.lastIndexOf("\n", token.start - 1) + 1, token.start)) && /^(?:--[ \t]*(?:migrate:down|\+goose[ \t]+down|\+migrate[ \t]+down)\b|----[ \t]*create above[ \t]*\/[ \t]*drop below[ \t]*----)/iu.test(
+      token.text
+    )
+  );
+  const up = down === void 0 ? text : text.slice(0, down.start);
+  const protectedTokens = tokens2.filter(
+    (token) => token.kind === "quoted" || token.kind === "comment"
+  );
+  const strip = dialect === "postgres" ? /^\\(?:un)?restrict\b.*$/gmu : /^[ \t]*create[ \t]+table[ \t]+(?:if[ \t]+not[ \t]+exists[ \t]+)?["'`[]?sqlite_sequence["'`\]]?[ \t]*\([^;]*\);?/gimu;
+  return up.replace(
+    strip,
+    (match, offset) => protectedTokens.some((token) => token.start <= offset && offset < token.end) ? match : ""
+  );
+}
+
+// src/analysis.ts
+var ReyloError = class _ReyloError extends Schema4.TaggedError(
+  "reylo-effect/ReyloError"
+)("ReyloError", {
+  message: Schema4.String,
+  cause: Schema4.Defect()
+}) {
+  static from = (cause) => new _ReyloError({ message: describeCause(cause), cause });
+};
+var LexError = class extends Schema4.TaggedError(
+  "reylo-effect/LexError"
+)("LexError", {
+  message: Schema4.String,
+  cause: Schema4.Defect()
+}) {
+};
+var SchemaSetting = Schema4.Union([Schema4.String, Schema4.NonEmptyArray(Schema4.String)]);
+var IntegersSetting = Schema4.Literals(["bigint", "number"]);
+var OWN_KEYS = [
+  "schema",
+  "integers",
+  "postgres_numbers",
+  "retry_reads",
+  "result_names",
+  "offline"
+];
+var StoredAnalysis = Schema4.fromJsonString(
+  Schema4.Struct({ identity: Schema4.String, analysis: Schema4.Unknown })
+);
+function findProject(from) {
+  const configured = process.env.REYLO_CONFIG;
+  if (configured) return { dir: packageDir(from), file: resolve2(configured) };
+  let owner;
+  for (let dir = resolve2(from); ; dir = dirname3(dir)) {
+    const file = PROJECT_FILES.map((name) => join5(dir, name)).find((path) => existsSync4(path));
+    if (file !== void 0) return { dir, file };
+    if (owner === void 0 && existsSync4(join5(dir, "package.json")))
+      owner = { dir, stop: workspaceRoot(dir) ?? dir };
+    if (dir === owner?.stop) return { dir: owner.dir };
+    if (dirname3(dir) === dir) return { dir: resolve2(from) };
+  }
+}
+var WorkspacePatterns = Schema4.Array(Schema4.String);
+var PackageWorkspaces = Schema4.Struct({
+  workspaces: Schema4.Union([WorkspacePatterns, Schema4.Struct({ packages: WorkspacePatterns })])
+});
+var PnpmWorkspace = Schema4.Struct({ packages: WorkspacePatterns });
+function workspaceRoot(member) {
+  for (let dir = member; dirname3(dir) !== dir; ) {
+    dir = dirname3(dir);
+    const patterns = workspacePatterns(dir);
+    if (patterns !== void 0) return listed(relative2(dir, member), patterns) ? dir : void 0;
+  }
+  return void 0;
+}
+function listed(path, patterns) {
+  const posixPath = path.split(sep).join("/");
+  const matches = (pattern) => posix.matchesGlob(posixPath, pattern.replace(/^\.\//u, "").replace(/\/+$/u, ""));
+  return patterns.some((pattern) => !pattern.startsWith("!") && matches(pattern)) && !patterns.some((pattern) => pattern.startsWith("!") && matches(pattern.slice(1)));
+}
+function workspacePatterns(dir) {
+  const pnpm = join5(dir, "pnpm-workspace.yaml");
+  if (existsSync4(pnpm)) {
+    let parsed2;
+    try {
+      parsed2 = parseDocument(readFileSync4(pnpm, "utf8")).toJS();
+    } catch {
+      return [];
+    }
+    return Option4.match(Schema4.decodeUnknownOption(PnpmWorkspace)(parsed2), {
+      onNone: () => [],
+      onSome: (workspace) => workspace.packages
+    });
+  }
+  const manifest = join5(dir, "package.json");
+  if (!existsSync4(manifest)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync4(manifest, "utf8"));
+  } catch {
+    return void 0;
+  }
+  return Option4.match(Schema4.decodeUnknownOption(PackageWorkspaces)(parsed), {
+    onNone: () => void 0,
+    onSome: ({ workspaces }) => "packages" in workspaces ? workspaces.packages : workspaces
+  });
+}
+function projectDirectory(from) {
+  return findProject(from).dir;
+}
+function resolveProject(host2, dir) {
+  const found = findProject(dir);
+  const both = PROJECT_FILES.map((name) => join5(found.dir, name));
+  const duplicate = !process.env.REYLO_CONFIG && both.every((path) => existsSync4(path)) ? `${both.map((path) => relative2(dir, path) || path).join(" and ")} are both project files; keep one.` : void 0;
+  const env = found.file === void 0 || process.env.REYLO_CONFIG ? process.env : { ...process.env, REYLO_CONFIG: found.file };
+  if (host2 instanceof MissingEngine) {
+    const project2 = resolveNativeProject(host2, dir, env);
+    return duplicate === void 0 ? project2 : { ...project2, error: duplicate };
+  }
+  let schema;
+  let integers;
+  let postgresNumbers;
+  let retryReads;
+  let resultNames;
+  let offline;
+  let error;
+  const configText = (text) => {
+    const document = parseDocument(text);
+    if (document.errors.length > 0 || !OWN_KEYS.some((name) => document.has(name))) return text;
+    const settings = document.toJS();
+    const read = (name) => Predicate4.isObject(settings) ? settings[name] : void 0;
+    if (document.has("schema")) {
+      const configured = Schema4.decodeUnknownOption(SchemaSetting)(read("schema"));
+      if (Option4.isNone(configured))
+        error = '"schema" in .reylo.yaml must be a nonempty list of file paths or glob patterns';
+      else if (Predicate4.isString(configured.value)) schema = [configured.value];
+      else schema = configured.value;
+    }
+    if (document.has("integers")) {
+      const configured = Schema4.decodeUnknownOption(IntegersSetting)(read("integers"));
+      if (Option4.isNone(configured))
+        error ??= '"integers" in .reylo.yaml must be "bigint" or "number"';
+      else integers = configured.value;
+    }
+    if (document.has("postgres_numbers")) {
+      if (read("postgres_numbers") !== "number")
+        error ??= '"postgres_numbers" in .reylo.yaml must be "number"';
+      else postgresNumbers = "number";
+    }
+    if (document.has("retry_reads")) {
+      const configured = read("retry_reads");
+      if (!Predicate4.isBoolean(configured))
+        error ??= '"retry_reads" in .reylo.yaml must be a boolean';
+      else retryReads = configured;
+    }
+    if (document.has("result_names")) {
+      if (read("result_names") !== "camelCase")
+        error ??= '"result_names" in .reylo.yaml must be "camelCase"';
+      else resultNames = "camelCase";
+    }
+    if (document.has("offline")) {
+      const configured = read("offline");
+      if (!Predicate4.isBoolean(configured)) error ??= '"offline" in .reylo.yaml must be a boolean';
+      else offline = configured;
+    }
+    return withoutOwnKeys(text, document);
+  };
+  const project = resolveNativeProject(host2, dir, env, configText);
+  const dialect = integers === "number" && project.dialect !== "sqlite" ? `"integers: number" in .reylo.yaml applies to SQLite; this project is ${project.dialect}` : void 0;
+  const numbers = postgresNumbers !== void 0 && project.dialect !== "postgres" ? '"postgres_numbers" in .reylo.yaml applies only to PostgreSQL' : void 0;
+  return {
+    ...project,
+    schema,
+    integers,
+    postgresNumbers,
+    retryReads,
+    resultNames,
+    // The environment decides over the file, so one checkout serves CI and production.
+    offline: offlineFrom(env) ?? offline ?? false,
+    error: duplicate ?? error ?? project.error ?? dialect ?? numbers
+  };
+}
+var utf82 = new TextEncoder();
+function withoutOwnKeys(text, document) {
+  const contents = document.contents;
+  if (!isMap(contents)) return text;
+  let blanked = text;
+  for (const pair of contents.items.toReversed()) {
+    const key = pair.key;
+    if (!isScalar(key) || !OWN_KEYS.some((name) => name === key.value)) continue;
+    let start = key.range?.[0];
+    let end = (isNode(pair.value) ? pair.value.range?.[1] : void 0) ?? key.range?.[1];
+    if (start === void 0 || end === void 0) continue;
+    if (contents.flow === true) {
+      const after = /^\s*,/u.exec(blanked.slice(end));
+      const before = /,\s*$/u.exec(blanked.slice(0, start));
+      if (after) end += after[0].length;
+      else if (before) start = before.index;
+    }
+    const spaced = blanked.slice(start, end).replace(/[^\n]/gu, (char) => " ".repeat(utf82.encode(char).length));
+    blanked = blanked.slice(0, start) + spaced + blanked.slice(end);
+  }
+  return blanked;
+}
+var anyEngineFor = (from) => Effect3.tryPromise({ try: () => anyEngine(from), catch: ReyloError.from });
+var engineFor = (project) => Effect3.tryPromise({ try: () => engine(project.dialect, project.root), catch: ReyloError.from });
+var nativeSession = Effect3.fn("Analysis.nativeSession")(function* (project, idle) {
+  const own = yield* engineFor(project).pipe(
+    Effect3.catch(
+      (failure2) => Effect3.succeed(
+        failure2.cause instanceof MissingEngine ? failure2.cause : new MissingEngine(failure2.message)
+      )
+    )
+  );
+  const native = new NativeSession(own, project, idle);
+  const session = {
+    project,
+    lex: (sql) => Effect3.try({
+      try: () => native.lex(sql),
+      catch: (cause) => new LexError({ message: describeCause(cause), cause })
+    }),
+    schema: Effect3.promise(() => native.schema()),
+    recheck: Effect3.promise(() => native.recheck()),
+    analyze: (sql) => Effect3.promise(() => native.analyze(sql)),
+    release: Effect3.promise(() => native.release()),
+    close: Effect3.promise(() => native.close())
+  };
+  return session;
+});
+var BUILD_IDLE = 250;
+var sessions = /* @__PURE__ */ new Map();
+var sessionFor = Effect3.fn("Analysis.session")(function* (project, idle) {
+  if (project.schema === void 0 && project.error === void 0) {
+    return yield* nativeSession(project, idle);
+  }
+  return yield* fileSession(project, yield* engineFor(project));
+});
+var Session = {
+  open: Effect3.fn("Analysis.Session.open")(function* (from) {
+    return yield* sessionFor(resolveProject(yield* anyEngineFor(from), from), Infinity);
+  }),
+  /** Not cached process-wide, nor released by `releaseConnections`. */
+  owned: Effect3.fn("Analysis.Session.owned")(function* (from) {
+    const root = projectDirectory(from);
+    return yield* sessionFor(resolveProject(yield* anyEngineFor(root), root), 2e3);
+  }),
+  for: Effect3.fn("Analysis.Session.for")(function* (from) {
+    const root = projectDirectory(from);
+    const project = resolveProject(yield* anyEngineFor(root), root);
+    const key = JSON.stringify(project);
+    const existing = sessions.get(key);
+    if (existing !== void 0) return existing;
+    const session = yield* sessionFor(project, BUILD_IDLE);
+    sessions.set(key, session);
+    return session;
+  })
+};
+var releaseConnections = Effect3.suspend(
+  () => Effect3.forEach([...sessions.values()], (session) => session.release, { discard: true })
+);
+var fileSession = Effect3.fn("Analysis.fileSession")(function* (project, engine2) {
+  const fs = yield* FileSystem2.FileSystem;
+  const path = yield* Path2.Path;
+  const scope = yield* Scope.make();
+  const fingerprint = yield* Ref.make(void 0);
+  const answers = new AnswerCache();
+  const database = yield* RcRef.make({
+    acquire: Effect3.flatMap(
+      schemaFiles(project.root, project.schema ?? []),
+      (found) => openSchemaDatabase(project.dialect, found.files, project.root)
+    ),
+    idleTimeToLive: "2 seconds"
+  }).pipe(Scope.provide(scope));
+  const release = RcRef.invalidate(database);
+  const platform = (effect) => effect.pipe(
+    Effect3.provideService(FileSystem2.FileSystem, fs),
+    Effect3.provideService(Path2.Path, path)
+  );
+  const schema = Effect3.gen(function* () {
+    if (project.error !== void 0) return yield* Effect3.fail(project.error);
+    if (project.dialect === "mysql") {
+      return yield* Effect3.fail(
+        '"schema" requires SQLite or Postgres; MySQL needs its server: use a MySQL 8.4 server'
+      );
+    }
+    const found = yield* schemaFiles(project.root, project.schema ?? []);
+    if (found.error !== void 0) return yield* Effect3.fail(found.error);
+    const value = yield* schemaFingerprint(project.root, found.files, project.dialect);
+    if (value !== (yield* Ref.get(fingerprint))) {
+      yield* release;
+      answers.clear();
+      yield* Ref.set(fingerprint, value);
+    }
+    return { value };
+  }).pipe(
+    Effect3.catch(
+      (failure2) => Effect3.gen(function* () {
+        yield* release;
+        yield* Ref.set(fingerprint, void 0);
+        return { value: null, fatal: true, error: messageOf2(failure2) };
+      })
+    ),
+    platform
+  );
+  const recheck = Effect3.gen(function* () {
+    const previous = yield* Ref.get(fingerprint);
+    return (yield* schema).value !== previous;
+  });
+  const cached = (entry, identity) => fs.readFileString(entry).pipe(
+    Effect3.flatMap(Schema4.decodeUnknownEffect(StoredAnalysis)),
+    Effect3.flatMap(
+      (stored) => stored.identity === identity ? (
+        // SAFETY: only `store` writes this file, keyed by engine, dialect, schema, and SQL.
+        Effect3.succeed(stored.analysis)
+      ) : Effect3.fail("stale")
+    ),
+    Effect3.option
+  );
+  const store = (entry, value) => {
+    const temporary = `${entry}.${randomUUID()}.tmp`;
+    return Effect3.gen(function* () {
+      yield* fs.makeDirectory(path.dirname(entry), { recursive: true });
+      yield* fs.writeFileString(temporary, JSON.stringify(value));
+      yield* fs.rename(temporary, entry);
+    }).pipe(Effect3.ensuring(Effect3.ignore(fs.remove(temporary, { force: true }))), Effect3.ignore);
+  };
+  const analyze = (sql) => Effect3.gen(function* () {
+    const status = yield* schema;
+    if (status.value === null) {
+      return { ok: false, code: 5, message: status.error ?? "Cannot load schema" };
+    }
+    const ping = engine2.call({ op: "ping" });
+    const identity = createHash3("sha256").update(JSON.stringify(["schema/1", ping, project.dialect, status.value, sql])).digest("hex");
+    const entry = path.join(project.root, ".reylo", "queries", `${identity}.json`);
+    const stored = yield* cached(entry, identity);
+    if (Option4.isSome(stored)) {
+      return { ok: true, analysis: stored.value, source: "cache", entry };
+    }
+    if (project.offline) return { ok: false, code: 4, message: OFFLINE_MISS };
+    const io = yield* RcRef.get(database);
+    const analysis = yield* Effect3.tryPromise({
+      try: () => engine2.analyze(sql, project.dialect, io, answers),
+      catch: ReyloError.from
+    });
+    yield* store(entry, { identity, analysis });
+    return { ok: true, analysis, source: "database", entry };
+  }).pipe(
+    Effect3.scoped,
+    Effect3.catch(
+      (failure2) => Effect3.succeed({ ok: false, code: 5, message: messageOf2(failure2) })
+    )
+  );
+  const session = {
+    project,
+    lex: (sql) => Effect3.try({
+      try: () => engine2.lex(sql, project.dialect),
+      catch: (cause) => new LexError({ message: describeCause(cause), cause })
+    }),
+    schema,
+    recheck,
+    analyze,
+    describeParameters: project.dialect === "postgres" ? (sql, parameterTypes) => Effect3.gen(function* () {
+      if (project.offline)
+        return yield* new ReyloError({
+          message: `${OFFLINE_MISS} Native JSON parameter descriptions are not cached.`,
+          cause: void 0
+        });
+      const io = yield* RcRef.get(database).pipe(Effect3.mapError(ReyloError.from));
+      const describe = io.describeParameters;
+      if (!describe)
+        return yield* new ReyloError({
+          message: "Explicit PostgreSQL parameter types are unavailable",
+          cause: void 0
+        });
+      return yield* Effect3.tryPromise({
+        try: () => describe(sql, parameterTypes),
+        catch: ReyloError.from
+      });
+    }).pipe(Effect3.scoped, platform) : void 0,
+    release,
+    close: Effect3.suspend(() => {
+      for (const [key, entry] of sessions) if (entry === session) sessions.delete(key);
+      return Scope.close(scope, Exit.void);
+    })
+  };
+  return session;
+});
+function messageOf2(failure2) {
+  return Predicate4.isString(failure2) ? failure2 : failure2.message;
+}
+
+// src/emit.ts
+import { exclusive } from "./host.js";
+
+// src/emit-contract.ts
+import { createHash as createHash4 } from "node:crypto";
+import { basename } from "node:path";
+import { Effect as Effect4, Result, String as String2 } from "effect";
+
+// src/map.ts
+import { Predicate as Predicate5 } from "effect";
+
+// src/schema-ir.ts
+import { Data } from "effect";
+var SchemaIR = Data.taggedEnum();
+var codec = (name) => SchemaIR.Codec({ name });
+var effectSchema = (name) => SchemaIR.Schema({ name });
+var nullOr = (item, nullable = true) => nullable ? SchemaIR.NullOr({ item }) : item;
+var arrayOf = (item) => SchemaIR.Array({ item });
+var json = (item) => SchemaIR.Json({ item });
+var union = (members) => SchemaIR.Union({ members });
+var struct = (fields) => SchemaIR.Struct({ fields });
+function nonNull(schema) {
+  return SchemaIR.$is("NullOr")(schema) ? schema.item : void 0;
+}
+function sameSchema(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function admits(wider2, narrower) {
+  const inner = nonNull(wider2);
+  return sameSchema(wider2, narrower) || inner !== void 0 && sameSchema(inner, narrower);
+}
+var printSchema = SchemaIR.$match({
+  Codec: ({ name }) => name,
+  Schema: ({ name }) => `Schema.${name}`,
+  Ref: ({ identifier: identifier2 }) => identifier2,
+  Literal: ({ value }) => `Schema.Literal(${JSON.stringify(value)})`,
+  Literals: ({ values }) => `Schema.Literals([${values.map((value) => JSON.stringify(value)).join(", ")}])`,
+  NullOr: ({ item }) => `Schema.NullOr(${printSchema(item)})`,
+  Array: ({ item }) => `Schema.Array(${printSchema(item)})`,
+  Tuple: ({ items }) => `Schema.Tuple([${items.map(printSchema).join(", ")}])`,
+  Struct: ({ fields }) => fields.length === 0 ? "Schema.Struct({})" : `Schema.Struct({ ${printFields(fields)} })`,
+  Union: ({ members }) => `Schema.Union([${members.map(printSchema).join(", ")}])`,
+  Json: ({ item }) => `Json(${printSchema(item)})`
+});
+function printFields(fields) {
+  return fields.map((field) => `${schemaIdent(field.name)}: ${printField(field)}`).join(", ");
+}
+function printField(field) {
+  const printed = printSchema(field.schema);
+  return field.optional === true ? `Schema.optionalKey(${printed})` : printed;
+}
+var none = () => [];
+var schemaBindings = SchemaIR.$match({
+  Codec: ({ name }) => [name],
+  Schema: none,
+  Ref: none,
+  Literal: none,
+  Literals: none,
+  NullOr: ({ item }) => schemaBindings(item),
+  Array: ({ item }) => schemaBindings(item),
+  Json: ({ item }) => ["Json", ...schemaBindings(item)],
+  Tuple: ({ items }) => items.flatMap(schemaBindings),
+  Union: ({ members }) => members.flatMap(schemaBindings),
+  Struct: ({ fields }) => fields.flatMap((field) => schemaBindings(field.schema))
+});
+function schemaIdent(name) {
+  if (name === "__proto__") return '["__proto__"]';
+  return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+
+// src/map.ts
+var SQLITE_COLUMN = {
+  dialect: "sqlite",
+  role: "column",
+  insideJson: false,
+  jsonText: false,
+  integers: "bigint"
+};
+function emitContext(over = {}) {
+  return { ...SQLITE_COLUMN, ...over };
+}
+var INT = effectSchema("Int");
+var INTEGER = codec("Integer");
+var REAL = codec("Real");
+var TEXT = codec("Text");
+var BLOB = codec("Blob");
+var BOOLEAN = effectSchema("Boolean");
+var DATE = effectSchema("Date");
+var UNKNOWN = effectSchema("Unknown");
+var INSTANT = codec("Instant");
+var BOOL = codec("Bool");
+var JSON_BOOL = codec("JsonBool");
+var JSON_INTEGER = codec("JsonInteger");
+var MYSQL_BIGINT = codec("MysqlBigInt");
+var POSTGRES_TIME = codec("PostgresTime");
+var DYNAMIC = codec("Dynamic");
+var SAFE_INTEGER = codec("SafeInteger");
+var SAFE_DYNAMIC = codec("SafeDynamic");
+var POSTGRES = {
+  int2: INT,
+  int4: INT,
+  int8: INTEGER,
+  bigint: INTEGER,
+  bool: BOOLEAN,
+  boolean: BOOLEAN,
+  numeric: TEXT,
+  decimal: TEXT,
+  date: TEXT,
+  timestamp: DATE,
+  timestamptz: DATE,
+  time: INTEGER,
+  timetz: TEXT,
+  float4: REAL,
+  float8: REAL,
+  text: TEXT,
+  varchar: TEXT,
+  name: TEXT,
+  uuid: TEXT,
+  bytea: BLOB,
+  json: UNKNOWN,
+  jsonb: UNKNOWN
+};
+var POSTGRES_JSON = {
+  ...POSTGRES,
+  int8: INT,
+  bigint: INT,
+  numeric: REAL,
+  decimal: REAL,
+  timestamp: TEXT,
+  timestamptz: TEXT,
+  time: TEXT,
+  bytea: TEXT
+};
+var MYSQL = {
+  tinyint: INT,
+  smallint: INT,
+  mediumint: INT,
+  int: INT,
+  integer: INT,
+  int4: INT,
+  year: INT,
+  int8: MYSQL_BIGINT,
+  bigint: MYSQL_BIGINT,
+  bool: JSON_BOOL,
+  boolean: JSON_BOOL,
+  numeric: TEXT,
+  decimal: TEXT,
+  float: REAL,
+  double: REAL,
+  real: REAL,
+  float4: REAL,
+  float8: REAL,
+  text: TEXT,
+  char: TEXT,
+  varchar: TEXT,
+  longtext: TEXT,
+  date: DATE,
+  datetime: DATE,
+  timestamp: DATE,
+  time: TEXT,
+  json: UNKNOWN,
+  blob: BLOB,
+  binary: BLOB,
+  varbinary: BLOB
+};
+var MYSQL_JSON = {
+  ...MYSQL,
+  int8: INT,
+  bigint: INT,
+  numeric: REAL,
+  decimal: REAL,
+  date: TEXT,
+  datetime: TEXT,
+  timestamp: TEXT
+};
+var PARAMETER_CODEC = {
+  postgres: { time: POSTGRES_TIME, tid: TEXT }
+};
+var CAST = {
+  sqlite: {
+    date: INSTANT,
+    datetime: INSTANT,
+    timestamp: INSTANT,
+    timestamptz: INSTANT,
+    bool: BOOL,
+    boolean: BOOL
+  },
+  postgres: {
+    date: TEXT,
+    datetime: INSTANT,
+    timestamp: DATE,
+    timestamptz: DATE,
+    time: POSTGRES_TIME,
+    timetz: TEXT,
+    bool: BOOLEAN,
+    boolean: BOOLEAN
+  },
+  mysql: {
+    date: DATE,
+    datetime: DATE,
+    timestamp: DATE,
+    timestamptz: DATE,
+    bool: JSON_BOOL,
+    boolean: JSON_BOOL
+  }
+};
+var SCALAR = {
+  integer: "integer",
+  int: "integer",
+  int2: "integer",
+  int4: "integer",
+  int8: "integer",
+  bigint: "integer",
+  real: "real",
+  float: "real",
+  float4: "real",
+  float8: "real",
+  double: "real",
+  text: "text",
+  string: "text",
+  blob: "blob",
+  bytea: "blob",
+  numeric: "numeric",
+  bool: "bool",
+  boolean: "bool",
+  date: "instant",
+  datetime: "instant",
+  timestamp: "instant",
+  timestamptz: "instant"
+};
+var BINDING = {
+  integer: "Integer",
+  real: "Real",
+  text: "Text",
+  blob: "Blob",
+  integerOrReal: "IntegerOrReal",
+  numeric: "Numeric",
+  dynamic: "Dynamic",
+  bool: "Bool",
+  instant: "Instant"
+};
+var JSON_BINDING = {
+  integer: "JsonInteger",
+  bool: "JsonBool"
+};
+var NUMBER_BINDING = {
+  integer: "SafeInteger",
+  blob: "SafeBlob",
+  integerOrReal: "SafeReal",
+  numeric: "SafeNumeric",
+  dynamic: "SafeDynamic",
+  bool: "JsonBool"
+};
+function storageOf(type) {
+  if (type.kind === "unknown") return { ok: true, storage: "dynamic" };
+  if (type.kind !== "scalar") {
+    return { ok: false, reason: `${type.kind} results are not a single storage class` };
+  }
+  const parts = type.name.split("|").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (parts.length === 0) {
+    return { ok: false, reason: "the analyzer reported a scalar with no type name" };
+  }
+  const mapped = [];
+  for (const part of parts) {
+    const kind = isKey(SCALAR, part) ? SCALAR[part] : void 0;
+    if (kind === void 0) {
+      return {
+        ok: false,
+        reason: `SQLite type \`${part}\` has no established storage representation`
+      };
+    }
+    mapped.push(kind);
+  }
+  const storage = combine(mapped);
+  if (storage === void 0) {
+    return {
+      ok: false,
+      reason: `SQLite type \`${type.name}\` has no established storage representation`
+    };
+  }
+  return { ok: true, storage };
+}
+function combine(parts) {
+  const set = new Set(parts);
+  if (set.size === 1) return parts[0];
+  const kinds = [...set];
+  const only = (...allowed) => kinds.every((kind) => allowed.includes(kind));
+  if (only("integer", "real", "integerOrReal")) return "integerOrReal";
+  if (only("integer", "real", "integerOrReal", "text", "numeric")) return "numeric";
+  if (only("integer", "real", "integerOrReal", "text", "numeric", "blob", "dynamic"))
+    return "dynamic";
+  return void 0;
+}
+function schemaExpr(storage, nullable, emit) {
+  const binding = (emit.integers === "number" ? NUMBER_BINDING[storage] : void 0) ?? (emit.insideJson ? JSON_BINDING[storage] : void 0) ?? BINDING[storage];
+  return withNull(codec(binding), nullable);
+}
+function schemaOf(type, nullable, emit = SQLITE_COLUMN) {
+  switch (type.kind) {
+    case "array":
+      return arrayExpr(type, nullable, emit);
+    case "scalar":
+      return scalarExpr(type, nullable, emit);
+    case "unknown":
+      return withNull(dynamicOf(emit), nullable);
+    case "object":
+      return objectExpr(type.fields, nullable, emit);
+    case "json":
+      return jsonKindExpr(type.schema, nullable, emit);
+    case "rows":
+      return rowsExpr(type, nullable, emit);
+    case "enum":
+    case "composite":
+    case "list":
+      return { ok: false, reason: `${type.kind} results have no storage representation` };
+  }
+}
+function applyCast(mapped, cast, nullable, dialect, integers = "bigint") {
+  if (!mapped.ok || cast === void 0) return mapped;
+  const codec2 = isKey(CAST[dialect], cast) ? CAST[dialect][cast] : void 0;
+  if (codec2 === void 0) return mapped;
+  return withNull(codec2 === BOOL && integers === "number" ? JSON_BOOL : codec2, nullable);
+}
+function scalarExpr(type, nullable, emit) {
+  if (emit.dialect !== "sqlite") return namedScalar(emit.dialect, type.name, nullable, emit);
+  const storage = storageOf(type);
+  if (!storage.ok) return storage;
+  return schemaExpr(storage.storage, nullable, emit);
+}
+function namedScalar(dialect, name, nullable, emit) {
+  const parts = name.split("|").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (parts.length === 0)
+    return { ok: false, reason: `the analyzer reported a ${dialect} scalar with no type name` };
+  const mapped = [];
+  for (const part of parts) {
+    const expr = codecFor(dialect, part, emit);
+    if (expr === void 0)
+      return {
+        ok: false,
+        reason: `${dialect} type \`${part}\` has no established storage representation`
+      };
+    mapped.push(expr);
+  }
+  return withNull(mapped.length === 1 ? mapped[0] : union(mapped), nullable);
+}
+function codecFor(dialect, name, emit) {
+  if (dialect === "postgres" && emit.insideJson && emit.role === "column")
+    return isKey(POSTGRES_JSON, name) ? POSTGRES_JSON[name] : void 0;
+  if (dialect === "postgres" && emit.postgresNumbers === "number" && emit.role === "column") {
+    if (name === "int8" || name === "bigint") return SAFE_INTEGER;
+    if (name === "numeric" || name === "decimal") return codec("PostgresNumeric");
+  }
+  if (dialect === "mysql" && emit.insideJson && emit.role === "column")
+    return isKey(MYSQL_JSON, name) ? MYSQL_JSON[name] : void 0;
+  if (emit.role === "parameter") {
+    if (dialect === "postgres" && emit.insideJson && name === "bytea") return codec("PostgresBytea");
+    const overrides = PARAMETER_CODEC[dialect];
+    const override = overrides !== void 0 && isKey(overrides, name) ? overrides[name] : void 0;
+    if (override !== void 0) return override;
+  }
+  if (dialect === "postgres") return isKey(POSTGRES, name) ? POSTGRES[name] : void 0;
+  return isKey(MYSQL, name) ? MYSQL[name] : void 0;
+}
+function isKey(table, name) {
+  return Object.hasOwn(table, name);
+}
+function forChild(emit, kind) {
+  const cleared = { ...emit, jsonText: false };
+  if (kind === "object") return { ...cleared, insideJson: true };
+  if (kind === "rows")
+    return { ...cleared, insideJson: emit.insideJson || emit.dialect === "sqlite" || emit.jsonText };
+  return cleared;
+}
+function wrapsJson(emit, kind) {
+  if (kind === "object") return emit.dialect === "sqlite" && !emit.insideJson;
+  return emit.dialect === "sqlite" || emit.jsonText;
+}
+function arrayExpr(type, nullable, emit) {
+  const nullableItems = emit.role === "column" ? type.nullable_items !== false : type.nullable_items === true;
+  const item = schemaOf(type.of, nullableItems, forChild(emit, "keep"));
+  if (!item.ok) return item;
+  return { ok: true, schema: nullOr(arrayOf(item.schema), nullable) };
+}
+function objectExpr(fields, nullable, emit) {
+  const built = structExpr(fields, forChild(emit, "object"));
+  if (!built.ok) return built;
+  return jsonWrapped(built, nullable, wrapsJson(emit, "object"));
+}
+function jsonKindExpr(schema, nullable, emit) {
+  const built = schema === void 0 ? withNull(UNKNOWN, false) : jsonSchemaExpr(schema, emit);
+  if (!built.ok) return built;
+  return jsonWrapped(built, nullable, wrapsJson(emit, "json"));
+}
+function rowsExpr(type, nullable, emit) {
+  if (type.fields.length === 0) return { ok: false, reason: "row parameters have no fields" };
+  const built = structExpr(type.fields, forChild(emit, "rows"));
+  if (!built.ok) return built;
+  const body = type.one ? built : { ok: true, schema: arrayOf(built.schema) };
+  return jsonWrapped(body, nullable, wrapsJson(emit, "rows"));
+}
+function structExpr(fields, emit) {
+  const parts = [];
+  const child = forChild(emit, "keep");
+  for (const field of fields) {
+    const mapped = schemaOf(field.type, field.nullable, child);
+    if (!mapped.ok) return mapped;
+    parts.push({ name: field.name, schema: mapped.schema, optional: field.optional === true });
+  }
+  return { ok: true, schema: struct(parts) };
+}
+function jsonSchemaExpr(schema, emit) {
+  if (schema === true) return withNull(UNKNOWN, false);
+  if (schema === false) return { ok: false, reason: "the JSON schema admits no value" };
+  if (!Predicate5.isObjectOrArray(schema))
+    return { ok: false, reason: "the JSON schema is not an object" };
+  if (Array.isArray(schema.anyOf)) {
+    return unionExpr(schema.anyOf.filter(isJsonSchema), emit);
+  }
+  if (Array.isArray(schema.enum)) {
+    const literals = schema.enum.filter(
+      (entry) => entry === null || Predicate5.isString(entry) || Predicate5.isNumber(entry) || Predicate5.isBoolean(entry)
+    );
+    if (literals.length !== schema.enum.length || literals.length === 0) {
+      return { ok: false, reason: "the JSON enum has no representable members" };
+    }
+    return { ok: true, schema: SchemaIR.Literals({ values: literals }) };
+  }
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    return unionExpr(
+      type.map((name) => ({ type: name })),
+      emit
+    );
+  }
+  if (type === "integer") return withNull(jsonIntegerOf(emit), false);
+  if (type === "number") return withNull(REAL, false);
+  if (type === "string") return withNull(TEXT, false);
+  if (type === "boolean") return withNull(BOOLEAN, false);
+  if (type === "null") return { ok: true, schema: effectSchema("Null") };
+  if (type === "array") return arraySchemaExpr(schema, emit);
+  if (type === "object" || schema.properties !== void 0) return objectSchemaExpr(schema, emit);
+  if (type === void 0) return withNull(UNKNOWN, false);
+  if (!Predicate5.isString(type))
+    return { ok: false, reason: "the JSON schema type is not a string" };
+  return { ok: false, reason: `JSON schema type \`${type}\` has no representation` };
+}
+function arraySchemaExpr(schema, emit) {
+  const prefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+  const items = schema.items;
+  if (prefix !== void 0) {
+    return together(
+      prefix.map((entry) => isJsonSchema(entry) ? entry : false),
+      emit,
+      (ok) => {
+        if (items !== false && items !== void 0) {
+          return {
+            ok: false,
+            reason: "a JSON array with both a prefix and additional items has no representation"
+          };
+        }
+        return { ok: true, schema: SchemaIR.Tuple({ items: ok.map((entry) => entry.schema) }) };
+      }
+    );
+  }
+  if (isJsonSchema(items) && !Predicate5.isBoolean(items)) {
+    const item = jsonSchemaExpr(items, emit);
+    if (!item.ok) return item;
+    return { ok: true, schema: arrayOf(item.schema) };
+  }
+  return { ok: false, reason: "the JSON array schema has no item schema" };
+}
+function objectSchemaExpr(schema, emit) {
+  const properties = schema.properties;
+  if (!Predicate5.isObject(properties)) {
+    return { ok: false, reason: "the JSON object schema has no properties" };
+  }
+  if (schema.additionalProperties !== void 0 && schema.additionalProperties !== false) {
+    return { ok: false, reason: "open JSON objects have no representation" };
+  }
+  const required = new Set(
+    Array.isArray(schema.required) ? schema.required.filter(Predicate5.isString) : []
+  );
+  const parts = [];
+  for (const [name, property] of Object.entries(properties)) {
+    const mapped = jsonSchemaExpr(isJsonSchema(property) ? property : false, emit);
+    if (!mapped.ok) return mapped;
+    parts.push({ name, schema: mapped.schema, optional: !required.has(name) });
+  }
+  return { ok: true, schema: struct(parts) };
+}
+function unionExpr(members, emit) {
+  if (members.length === 0) return { ok: false, reason: "the JSON union has no members" };
+  return together(members, emit, (ok) => {
+    if (ok.length === 1) return ok[0];
+    return { ok: true, schema: union(ok.map((entry) => entry.schema)) };
+  });
+}
+function together(members, emit, join7) {
+  const built = members.map((member) => jsonSchemaExpr(member, emit));
+  const failed = built.find((entry) => !entry.ok);
+  if (failed !== void 0 && !failed.ok) return failed;
+  return join7(built.filter((entry) => entry.ok));
+}
+function isJsonSchema(value) {
+  return Predicate5.isBoolean(value) || Predicate5.isObjectOrArray(value);
+}
+function dynamicOf(emit) {
+  return emit.dialect === "sqlite" && emit.integers === "number" ? SAFE_DYNAMIC : DYNAMIC;
+}
+function jsonIntegerOf(emit) {
+  if (emit.dialect !== "sqlite") return INT;
+  return emit.integers === "number" ? SAFE_INTEGER : JSON_INTEGER;
+}
+function withNull(schema, nullable) {
+  return { ok: true, schema: nullOr(schema, nullable) };
+}
+function jsonWrapped(inner, nullable, wrapJson) {
+  return { ok: true, schema: nullOr(wrapJson ? json(inner.schema) : inner.schema, nullable) };
+}
+
+// src/emit-contract.ts
+var TARGET = "effect-sql/5";
+var UNSUPPORTED = 30;
+function hashedField(field, bindings = schemaBindings(field.schema)) {
+  const expr = printField(field);
+  if (field.storageName === void 0) return { name: field.name, expr, bindings };
+  return { name: field.name, storageName: field.storageName, expr, bindings };
+}
+function printDeclaration(declaration) {
+  return `const ${declaration.identifier} = ${printSchema(declaration.schema)};`;
+}
+var withEntry = (check) => Effect4.suspend(() => {
+  const seen = {};
+  return Effect4.map(check(seen), (checked) => ({ ...checked, entry: seen.entry }));
+});
+var analyzeContract = Effect4.fn("Emit.analyzeContract")(function* (sql, owned) {
+  const refused = (message, code) => ({
+    ok: false,
+    diagnostics: [{ message, start: 0, length: 1, code }],
+    entry: void 0
+  });
+  const lexed = yield* Effect4.result(owned.lex(sql));
+  if (Result.isFailure(lexed)) return refused(lexed.failure.message, 1);
+  let outcome = yield* owned.analyze(sql);
+  if (outcome.ok && outcome.analysis.diagnostics.some((diagnostic) => diagnostic.code === 6) && (yield* owned.recheck)) {
+    outcome = yield* owned.analyze(sql);
+  }
+  if (!outcome.ok) return refused(outcome.message, outcome.code);
+  const diagnostics = outcome.analysis.diagnostics.map((diagnostic) => ({
+    message: diagnostic.message,
+    start: diagnostic.start,
+    length: diagnostic.length,
+    code: diagnostic.code
+  }));
+  if (diagnostics.length > 0) return { ok: false, diagnostics, entry: outcome.entry };
+  const contract = contractOf(
+    sql,
+    outcome.analysis,
+    lexed.success,
+    owned.project.dialect,
+    owned.project
+  );
+  return { ...contract, entry: outcome.entry };
+});
+function contractOf(source, analysis, lexed, dialect, settings) {
+  const { postgresNumbers, retryReads, resultNames } = settings;
+  const integers = settings.integers ?? "bigint";
+  const diagnostics = [];
+  const reject3 = (message, name) => {
+    const span = name === void 0 ? { start: 0, length: 1 } : spanOf(lexed, name, source);
+    diagnostics.push({ message, start: span.start, length: span.length, code: UNSUPPORTED });
+  };
+  const names = /* @__PURE__ */ new Map();
+  const row = [];
+  for (const structured of analysis.structured ?? []) {
+    const param = analysis.params.find((entry) => entry.name === structured.name);
+    if (param?.type.kind === "rows" && param.type.fields.some((field) => field.optional)) {
+      reject3(
+        `Parameter :${structured.name} is unsupported: MySQL structured inserts with optional fields require runtime column omission to preserve database defaults. Use an explicit INSERT column list instead.`,
+        structured.name
+      );
+    }
+  }
+  for (const column of analysis.columns) {
+    const name = resultNames === "camelCase" ? String2.snakeToCamel(column.name) : column.name;
+    const earlier = names.get(name);
+    if (name === "") {
+      reject3(`Column \`${column.name}\` has no camelCase name under result_names: camelCase.`);
+      continue;
+    }
+    if (earlier !== void 0) {
+      reject3(
+        earlier === column.name ? `Column \`${name}\` is duplicated; a row is an object keyed by column name.` : `Columns \`${earlier}\` and \`${column.name}\` both become \`${name}\` under result_names: camelCase.`
+      );
+      continue;
+    }
+    names.set(name, column.name);
+    const mapped = schemaOf(
+      column.type,
+      column.nullable,
+      emitContext({ dialect, integers, postgresNumbers })
+    );
+    if (!mapped.ok) {
+      reject3(`Column \`${column.name}\` is unsupported: ${mapped.reason}.`);
+      continue;
+    }
+    row.push({
+      name,
+      storageName: name === column.name ? void 0 : column.name,
+      schema: mapped.schema
+    });
+  }
+  const byName = new Map(analysis.params.map((param) => [param.name, param]));
+  const input = [];
+  for (const name of analysis.rewritten.order) {
+    const param = byName.get(name);
+    if (param === void 0) {
+      reject3(`Parameter :${name} is in the binding order but has no analyzed type.`, name);
+      continue;
+    }
+    if (param.type.kind === "unknown") {
+      reject3(
+        `Parameter :${name} is unsupported: nothing in the statement gives it a storage class. Cast it, as in :${name}::text.`,
+        name
+      );
+      continue;
+    }
+    const parameter = emitContext({
+      dialect,
+      integers,
+      postgresNumbers,
+      role: "parameter",
+      jsonText: dialect !== "sqlite" && (param.type.kind === "json" || param.type.kind === "rows")
+    });
+    const mapped = applyCast(
+      schemaOf(param.type, param.nullable, parameter),
+      param.cast,
+      param.nullable,
+      dialect,
+      integers
+    );
+    if (!mapped.ok) {
+      reject3(`Parameter :${name} is unsupported: ${mapped.reason}.`, name);
+      continue;
+    }
+    input.push({ name, schema: mapped.schema });
+  }
+  for (const param of analysis.params) {
+    if (!analysis.rewritten.order.includes(param.name)) {
+      reject3(
+        `Parameter :${param.name} was analyzed but is missing from the binding order.`,
+        param.name
+      );
+    }
+  }
+  if (diagnostics.length > 0) return { ok: false, diagnostics };
+  const cardinality = analysis.cardinality;
+  const sql = analysis.rewritten.sql;
+  const order = analysis.rewritten.order;
+  const hashed = {
+    target: TARGET,
+    dialect,
+    cardinality,
+    sql,
+    order,
+    input: input.map((field) => [field.name, printSchema(field.schema)]),
+    row: row.map(
+      (field) => field.storageName === void 0 ? [field.name, printSchema(field.schema)] : [field.name, printSchema(field.schema), field.storageName]
+    ),
+    // JSON drops an undefined setting, so contracts without it keep their hash.
+    postgresNumbers,
+    retryReads
+  };
+  const contractHash = sha2562(
+    JSON.stringify(integers === "bigint" ? hashed : { ...hashed, integers })
+  );
+  const fresh = analysis.fresh === void 0 ? void 0 : { query: analysis.fresh.query, rows: analysis.fresh.rows };
+  return {
+    ok: true,
+    value: {
+      identity: sha2562(source),
+      sql,
+      sqlHash: sha2562(sql),
+      contractHash,
+      cardinality,
+      order,
+      input,
+      row,
+      fresh,
+      dialect,
+      integers: integers === "number" ? integers : void 0,
+      retryReads
+    }
+  };
+}
+function render(path, contract) {
+  const name = basename(path).replace(/\.sql$/i, "") || "query";
+  const bindings = [
+    ...new Set(
+      [...contract.declarations ?? [], ...contract.input, ...contract.row].flatMap(
+        (entry) => schemaBindings(entry.schema)
+      )
+    )
+  ].sort();
+  const imported = ["makeQuery", ...bindings].join(", ");
+  const renamed = contract.row.flatMap(
+    (field) => field.storageName === void 0 ? [] : [[field.storageName, field.name]]
+  );
+  const lines = [
+    `import { Schema } from "effect";`,
+    `import { ${imported} } from "reylo-effect/runtime";`,
+    ``,
+    ...(contract.declarations ?? []).map(printDeclaration),
+    `export const Input = Schema.Struct({ ${printFields(contract.input)} });`,
+    `export const Row = Schema.Struct({ ${printFields(contract.row)} });`,
+    ``,
+    `export default makeQuery({`,
+    `  name: ${JSON.stringify(name)},`,
+    `  identity: ${JSON.stringify(contract.identity)},`,
+    `  sql: ${JSON.stringify(contract.sql)},`,
+    `  sqlHash: ${JSON.stringify(contract.sqlHash)},`,
+    `  contractHash: ${JSON.stringify(contract.contractHash)},`,
+    `  cardinality: ${JSON.stringify(contract.cardinality)},`,
+    `  order: ${JSON.stringify(contract.order)},`,
+    `  dialect: ${JSON.stringify(contract.dialect)},`,
+    `  input: Input,`,
+    `  row: Row,`
+  ];
+  if (contract.program !== void 0) lines.push(`  program: ${JSON.stringify(contract.program)},`);
+  if (contract.fresh !== void 0) lines.push(`  fresh: ${JSON.stringify(contract.fresh)},`);
+  if (contract.integers !== void 0)
+    lines.push(`  integers: ${JSON.stringify(contract.integers)},`);
+  if (renamed.length > 0) lines.push(`  rowNames: ${JSON.stringify(renamed)},`);
+  if (contract.retryReads !== void 0)
+    lines.push(`  retryReads: ${JSON.stringify(contract.retryReads)},`);
+  lines.push(`});`, ``);
+  return lines.join("\n");
+}
+function spanOf(lexed, name, source) {
+  const placeholder = lexed?.placeholders.find((item) => item.name === name);
+  if (placeholder === void 0) return { start: 0, length: 1 };
+  const written = Buffer.from(source, "utf8").subarray(placeholder.start, placeholder.end).toString("utf8").replace(/\s*::[\s\S]*$/, "");
+  return { start: placeholder.start, length: Math.max(1, Buffer.byteLength(written)) };
+}
+function sha2562(text) {
+  return createHash4("sha256").update(text).digest("hex");
+}
+
+// src/emit-repeated.ts
+import { Effect as Effect5 } from "effect";
+
+// src/repeated-sql.ts
+var repeatPattern = /^\/\*\s*@repeat\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*([A-Za-z_][A-Za-z0-9_]*)\s+(AND|OR)\s*\*\/$/u;
+var casePattern = /^\/\*\s*@case\s+([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\s*\*\/$/u;
+var endPattern = /^\/\*\s*@endcase\s*\*\/$/u;
+var directive = /^\/\*\s*@(repeat|case|endcase)\b/u;
+var identifier = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+var reserved = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var bytes = (source, index) => Buffer.byteLength(source.slice(0, index));
+var problem = (source, message, start, end = start + 1) => ({
+  message,
+  start: bytes(source, start),
+  length: Math.max(1, Buffer.byteLength(source.slice(start, end))),
+  code: 30
+});
+var bindingScope = (group, tag) => group === void 0 ? "root" : JSON.stringify([group, tag]);
+function parseRepeatedSql(source, dialect = "postgres") {
+  const tokens2 = [...sqlTokens(source, dialect, true)];
+  const marked = tokens2.filter((token) => token.kind === "comment" && directive.test(token.text));
+  if (!marked.length) return { ok: true, value: void 0 };
+  const diagnostics = [];
+  const definitions = [];
+  let open;
+  let footer = source.length;
+  for (const token of marked) {
+    const branch = casePattern.exec(token.text);
+    if (branch) {
+      if (open)
+        diagnostics.push(
+          problem(source, "Expression cases cannot be nested", token.start, token.end)
+        );
+      else {
+        footer = Math.min(footer, token.start);
+        open = { group: branch[1], tag: branch[2], start: token.start, body: token.end };
+      }
+    } else if (endPattern.test(token.text)) {
+      if (!open) diagnostics.push(problem(source, "Unexpected @endcase", token.start, token.end));
+      else {
+        definitions.push({ ...open, end: token.start, close: token.end });
+        open = void 0;
+      }
+    } else if (!repeatPattern.test(token.text))
+      diagnostics.push(
+        problem(source, "Malformed repeated-expression directive", token.start, token.end)
+      );
+  }
+  if (open) diagnostics.push(problem(source, "Expression case is missing @endcase", open.start));
+  for (const token of tokens2) {
+    if (token.start < footer || token.kind === "comment") continue;
+    if (!definitions.some(
+      (definition) => token.start >= definition.body && token.end <= definition.end
+    ))
+      diagnostics.push(
+        problem(source, "Only expression definitions may follow the query", token.start, token.end)
+      );
+  }
+  const pieces = (start, end, tagged) => {
+    const parts = [];
+    const local = tokens2.filter((token) => token.start >= start && token.end <= end);
+    let cursor = start;
+    const flush = (until) => {
+      if (until > cursor) parts.push({ text: source.slice(cursor, until), start: cursor });
+    };
+    for (const [index, token] of local.entries()) {
+      const repeat = token.kind === "comment" ? repeatPattern.exec(token.text) : null;
+      if (repeat) {
+        const name2 = repeat[1];
+        if (reserved.has(name2) || tagged && name2 === "_tag")
+          diagnostics.push(
+            problem(source, "Reserved expression-list parameter name", token.start, token.end)
+          );
+        flush(token.start);
+        parts.push({
+          repeat: name2,
+          group: repeat[2],
+          join: repeat[3] === "AND" ? "AND" : "OR",
+          start: token.start,
+          end: token.end
+        });
+        cursor = token.end;
+        continue;
+      }
+      const next = local[index + 1];
+      const previous = local[index - 1];
+      if (token.kind !== "symbol" || token.text !== ":" || !next || next.kind !== "word" || next.start !== token.end || previous?.text === ":" && previous.end === token.start)
+        continue;
+      const name = next.text;
+      if (!identifier.test(name) || reserved.has(name) || tagged && name === "_tag")
+        diagnostics.push(
+          problem(source, "Unsupported repeated-expression parameter name", token.start, next.end)
+        );
+      flush(token.start);
+      parts.push({ parameter: name, start: token.start, end: next.end });
+      cursor = next.end;
+    }
+    flush(end);
+    return parts;
+  };
+  if (splitSql(source.slice(0, footer), dialect).length !== 1)
+    diagnostics.push(problem(source, "Repeated expressions require exactly one statement", 0));
+  const root = pieces(0, footer, false);
+  const groups = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    const bodyTokens = tokens2.filter(
+      (token) => token.start >= definition.body && token.end <= definition.end && (token.kind !== "comment" || repeatPattern.test(token.text))
+    );
+    const stack = [];
+    for (const token of bodyTokens) {
+      if (token.kind !== "symbol") continue;
+      if (token.text === ";")
+        diagnostics.push(
+          problem(source, "Expression cases cannot contain statements", token.start, token.end)
+        );
+      if (token.text === "(" || token.text === "[") stack.push(token);
+      else if (token.text === ")" || token.text === "]") {
+        const first = stack.pop();
+        if (!first || (first.text === "(" ? token.text !== ")" : token.text !== "]"))
+          diagnostics.push(problem(source, "Unbalanced expression case", token.start, token.end));
+      }
+    }
+    if (stack.length || !bodyTokens.length)
+      diagnostics.push(
+        problem(
+          source,
+          "Expression case must contain a balanced expression",
+          definition.body,
+          definition.end
+        )
+      );
+    const cases = groups.get(definition.group) ?? [];
+    if (cases.some((branch) => branch.tag === definition.tag))
+      diagnostics.push(problem(source, "Duplicate expression case", definition.start));
+    cases.push({
+      tag: definition.tag,
+      parts: pieces(definition.body, definition.end, true),
+      start: definition.start
+    });
+    groups.set(definition.group, cases);
+  }
+  const active = /* @__PURE__ */ new Set();
+  const reached = /* @__PURE__ */ new Set();
+  const visit = (parts) => {
+    const names = /* @__PURE__ */ new Map();
+    for (const part of parts) {
+      if ("text" in part) continue;
+      const name = "parameter" in part ? part.parameter : part.repeat;
+      const parameterKind = "parameter" in part ? "scalar" : part.group;
+      const found = names.get(name);
+      if (found !== void 0 && found !== parameterKind)
+        diagnostics.push(
+          problem(
+            source,
+            "A parameter cannot have conflicting expression shapes",
+            part.start,
+            part.end
+          )
+        );
+      names.set(name, parameterKind);
+      if ("parameter" in part) continue;
+      const cases = groups.get(part.group);
+      if (!cases) {
+        diagnostics.push(
+          problem(source, `Unknown expression group: ${part.group}`, part.start, part.end)
+        );
+        continue;
+      }
+      if (active.has(part.group)) {
+        diagnostics.push(
+          problem(source, "Expression groups cannot be recursive", part.start, part.end)
+        );
+        continue;
+      }
+      if (reached.has(part.group)) continue;
+      active.add(part.group);
+      for (const branch of cases) visit(branch.parts);
+      active.delete(part.group);
+      reached.add(part.group);
+    }
+  };
+  visit(root);
+  for (const [name, cases] of groups)
+    if (!reached.has(name))
+      diagnostics.push(problem(source, `Unused expression group: ${name}`, cases[0].start));
+  if (diagnostics.length) return { ok: false, diagnostics };
+  const runtimeParts = (parts) => parts.map(
+    (part) => "text" in part ? part.text : "parameter" in part ? { parameter: part.parameter } : { repeat: part.repeat, group: part.group, join: part.join }
+  );
+  const sourceGroups = [...groups].map(([name, cases]) => ({ name, cases }));
+  return {
+    ok: true,
+    value: {
+      source,
+      root,
+      groups: sourceGroups,
+      program: {
+        root: runtimeParts(root),
+        groups: sourceGroups.map((group) => ({
+          name: group.name,
+          cases: group.cases.map((branch) => ({
+            tag: branch.tag,
+            parts: runtimeParts(branch.parts)
+          }))
+        }))
+      }
+    }
+  };
+}
+function repeatedSamples(query, dialect = "postgres") {
+  const groups = new Map(query.groups.map((group) => [group.name, group]));
+  const build = (empty, selected) => {
+    const sql = [];
+    const positional = [];
+    const origins = [];
+    const bindings = [];
+    let nodes = 0;
+    const append = (text, start, end) => {
+      sql.push(text);
+      const origin = bytes(query.source, start);
+      const length = Buffer.byteLength(text);
+      const width = end === void 0 ? length : Math.max(1, Buffer.byteLength(query.source.slice(start, end)));
+      for (let index = 0; index < length; index++) origins.push(origin + Math.min(index, width - 1));
+    };
+    const render2 = (parts, scope) => {
+      for (const part of parts) {
+        if (++nodes > 4096) return false;
+        if ("text" in part) {
+          append(part.text, part.start);
+          positional.push(part.text);
+        } else if ("parameter" in part) {
+          const alias = `__repeated_${bindings.length}`;
+          bindings.push({
+            alias,
+            scope,
+            name: part.parameter,
+            start: bytes(query.source, part.start),
+            end: bytes(query.source, part.end)
+          });
+          append(`:${alias}`, part.start, part.end);
+          positional.push(dialect === "sqlite" ? "?" : `$${bindings.length}`);
+        } else {
+          append("(", part.start, part.end);
+          positional.push("(");
+          const group = groups.get(part.group);
+          const cases = empty ? [] : group.cases.filter((branch) => selected?.group !== part.group || selected.tag === branch.tag).flatMap((branch) => [branch, branch]);
+          if (!cases.length) {
+            const value = part.join === "AND" ? "TRUE" : "FALSE";
+            append(value, part.start, part.end);
+            positional.push(value);
+          }
+          for (const [index, branch] of cases.entries()) {
+            if (index) {
+              const separator = `
+${part.join}
+`;
+              append(separator, part.start, part.end);
+              positional.push(separator);
+            }
+            append("(", branch.start);
+            positional.push("(");
+            if (!render2(branch.parts, bindingScope(part.group, branch.tag))) return false;
+            append("\n)", branch.start);
+            positional.push("\n)");
+          }
+          append("\n)", part.start);
+          positional.push("\n)");
+        }
+      }
+      return true;
+    };
+    if (!render2(query.root, bindingScope())) return void 0;
+    return {
+      sql: sql.join(""),
+      positional: positional.join(""),
+      bindings,
+      origins
+    };
+  };
+  const samples = [
+    build(true),
+    build(false),
+    ...query.groups.flatMap(
+      (group) => group.cases.map((branch) => build(false, { group: group.name, tag: branch.tag }))
+    )
+  ];
+  if (samples.some((sample) => sample === void 0))
+    return {
+      ok: false,
+      diagnostics: [
+        problem(
+          query.source,
+          "Expression definitions expand beyond the analysis limit; split the groups",
+          0
+        )
+      ]
+    };
+  return { ok: true, samples: samples.filter((sample) => sample !== void 0) };
+}
+function repeatedLocation(sample, diagnostic) {
+  const start = sample.origins[diagnostic.start] ?? 0;
+  const end = sample.origins[diagnostic.start + Math.max(1, diagnostic.length) - 1] ?? start;
+  return { ...diagnostic, start, length: Math.max(1, end - start + 1) };
+}
+
+// src/emit-repeated.ts
+var reject = (message, start = 0, length = 1) => ({
+  ok: false,
+  diagnostics: [{ message, start, length, code: 30 }]
+});
+var tokens = (sql, dialect) => JSON.stringify([...sqlTokens(sql, dialect)].map((token) => token.text));
+var compatible = (left, right) => admits(left, right) || admits(right, left);
+var wider = (left, right) => admits(left, right) ? left : right;
+var repeatedContract = (query, owned) => withEntry((seen) => checkRepeated(query, owned, seen));
+var checkRepeated = Effect5.fn("Emit.repeatedContract")(function* (query, owned, seen) {
+  const dialect = owned.project.dialect;
+  if (dialect !== "postgres" && dialect !== "sqlite")
+    return reject("Repeated expressions require Postgres or SQLite");
+  const expanded = repeatedSamples(query, dialect);
+  if (!expanded.ok) return expanded;
+  const checked = [];
+  const fields = /* @__PURE__ */ new Map();
+  for (const sample of expanded.samples) {
+    const mapped = yield* analyzeContract(sample.sql, owned);
+    seen.entry = mapped.entry ?? seen.entry;
+    if (!mapped.ok)
+      return {
+        ok: false,
+        diagnostics: mapped.diagnostics.map((diagnostic) => repeatedLocation(sample, diagnostic))
+      };
+    if (tokens(mapped.value.sql, dialect) !== tokens(sample.positional, dialect))
+      return reject(
+        "Repeated expressions do not support SQL requiring structural parameter rewrites"
+      );
+    checked.push(mapped.value);
+    const byAlias = new Map(mapped.value.input.map((field) => [field.name, field]));
+    if (byAlias.size !== sample.bindings.length || [...byAlias.keys()].some(
+      (alias) => !sample.bindings.some((binding) => binding.alias === alias)
+    ))
+      return reject("Repeated expressions require authored :name bindings for every parameter");
+    for (const binding of sample.bindings) {
+      const field = byAlias.get(binding.alias);
+      if (!field)
+        return reject(
+          `Missing analyzed expression parameter: ${binding.name}`,
+          binding.start,
+          binding.end - binding.start
+        );
+      const scope = fields.get(binding.scope) ?? /* @__PURE__ */ new Map();
+      const previous = scope.get(binding.name);
+      if (previous && !compatible(previous.schema, field.schema))
+        return reject(
+          `Expression parameter :${binding.name} has incompatible storage types in its query contexts`,
+          binding.start,
+          binding.end - binding.start
+        );
+      scope.set(binding.name, {
+        ...field,
+        name: binding.name,
+        schema: previous ? wider(field.schema, previous.schema) : field.schema
+      });
+      fields.set(binding.scope, scope);
+    }
+  }
+  const full = checked[1];
+  const row = full.row.map((field) => ({ ...field }));
+  for (const contract of checked) {
+    if (contract.row.length !== row.length)
+      return reject("Repeated expressions must retain a consistent result shape");
+    for (const [index, field] of contract.row.entries()) {
+      const previous = row[index];
+      if (field.name !== previous.name || field.storageName !== previous.storageName)
+        return reject("Repeated expressions must retain consistent result columns");
+      if (!compatible(field.schema, previous.schema))
+        return reject(
+          `Result column ${field.name} has incompatible expression-dependent storage types`
+        );
+      if (!sameSchema(field.schema, previous.schema) && admits(field.schema, previous.schema))
+        row[index] = field;
+    }
+  }
+  const cardinalities = new Set(checked.map((contract) => contract.cardinality));
+  if (cardinalities.has("none") && cardinalities.size > 1)
+    return reject("Repeated expressions cannot change whether a statement returns rows");
+  const cardinality = cardinalities.has("many") ? "many" : cardinalities.has("maybeOne") ? "maybeOne" : full.cardinality;
+  const groups = new Map(
+    query.groups.map((group, index) => [
+      group.name,
+      { ...group, identifier: `__ReyloGroup${index}` }
+    ])
+  );
+  const declarations = [];
+  const declared = /* @__PURE__ */ new Set();
+  const allBindings = /* @__PURE__ */ new Set();
+  const inputFieldsFor = (parts, scope) => {
+    const inputFields = new Map(fields.get(scope));
+    for (const part of parts) {
+      if (!("repeat" in part)) continue;
+      const group = groups.get(part.group);
+      declare(group.name);
+      inputFields.set(part.repeat, {
+        name: part.repeat,
+        schema: arrayOf(SchemaIR.Ref({ identifier: group.identifier }))
+      });
+    }
+    for (const field of inputFields.values())
+      for (const binding of schemaBindings(field.schema)) allBindings.add(binding);
+    return [...inputFields.values()];
+  };
+  const declare = (name) => {
+    if (declared.has(name)) return;
+    const group = groups.get(name);
+    const cases = group.cases.map((branch) => {
+      const branchFields = inputFieldsFor(branch.parts, bindingScope(name, branch.tag));
+      return struct([
+        { name: "_tag", schema: SchemaIR.Literal({ value: branch.tag }) },
+        ...branchFields.map((field) => ({ name: field.name, schema: field.schema }))
+      ]);
+    });
+    declarations.push({
+      identifier: group.identifier,
+      schema: cases.length === 1 ? cases[0] : union(cases)
+    });
+    declared.add(name);
+  };
+  const input = inputFieldsFor(query.root, bindingScope());
+  const identity = sha2562(query.source);
+  const contractHash = sha2562(
+    JSON.stringify({
+      target: TARGET,
+      identity,
+      program: query.program,
+      // Every input field once carried every binding the module imports.
+      input: input.map((field) => hashedField(field, [...allBindings])),
+      row: row.map((field) => hashedField(field)),
+      declarations: declarations.map(printDeclaration),
+      cardinality,
+      integers: full.integers,
+      postgresNumbers: owned.project.postgresNumbers,
+      retryReads: full.retryReads
+    })
+  );
+  return {
+    ok: true,
+    value: {
+      ...full,
+      identity,
+      contractHash,
+      cardinality,
+      input,
+      row,
+      order: input.map((field) => field.name),
+      program: query.program,
+      declarations
+    }
+  };
+});
+
+// src/emit-native-json.ts
+import { Cache, Duration, Effect as Effect6, Equal, Exit as Exit2, Hash, Option as Option5, Result as Result2, Schema as Schema5 } from "effect";
+
+// src/statement-program.ts
+import { Predicate as Predicate6 } from "effect";
+var isList = (value) => Array.isArray(value);
+var isRecord = (value) => Predicate6.isReadonlyObject(value) && !isList(value) && !(value instanceof Date) && !(value instanceof Uint8Array) && !(value instanceof ArrayBuffer);
+var statementCompiler = (program, dialect = "postgres") => {
+  const groups = new Map(program.groups.map((group) => [group.name, group]));
+  const active = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const verify = (parts) => {
+    for (const part of parts) {
+      if (Predicate6.isString(part) || "parameter" in part) continue;
+      if ("in" in part) {
+        if (!/^[A-Za-z_]\w*$/u.test(part.in.column)) throw new Error("Invalid checked IN column");
+        continue;
+      }
+      const group = groups.get(part.group);
+      if (!group) throw new Error(`Missing checked expression group: ${part.group}`);
+      if (active.has(group.name)) throw new Error(`Cyclic checked expression group: ${group.name}`);
+      if (new Set(group.cases.map((branch) => branch.tag)).size !== group.cases.length)
+        throw new Error(`Duplicate checked expression case: ${group.name}`);
+      if (visited.has(group.name)) continue;
+      active.add(group.name);
+      for (const branch of group.cases) verify(branch.parts);
+      active.delete(group.name);
+      visited.add(group.name);
+    }
+  };
+  if (groups.size !== program.groups.length) throw new Error("Duplicate checked expression group");
+  verify(program.root);
+  return (input) => {
+    const text = [];
+    const parameters = [];
+    const append = (parts, scope) => {
+      for (const part of parts) {
+        if (Predicate6.isString(part)) text.push(part);
+        else if ("parameter" in part) {
+          if (!Object.hasOwn(scope, part.parameter))
+            throw new Error(`Missing encoded SQL parameter: ${part.parameter}`);
+          parameters.push(scope[part.parameter]);
+          text.push(dialect === "sqlite" ? "?" : `$${parameters.length}`);
+        } else if ("in" in part) {
+          if (!Object.hasOwn(scope, part.in.parameter))
+            throw new Error(`Missing encoded SQL parameter: ${part.in.parameter}`);
+          const values = scope[part.in.parameter];
+          if (!isList(values))
+            throw new Error(`Expected checked IN argument list: ${part.in.parameter}`);
+          if (!values.length) text.push(" 1=0 ");
+          else {
+            text.push(` ${part.in.column} IN (`);
+            for (const [index, value] of values.entries()) {
+              if (index) text.push(",");
+              parameters.push(value);
+              text.push(dialect === "sqlite" ? "?" : `$${parameters.length}`);
+            }
+            text.push(") ");
+          }
+        } else {
+          const values = scope[part.repeat];
+          if (!isList(values)) throw new Error(`Expected encoded expression list: ${part.repeat}`);
+          const group = groups.get(part.group);
+          if (!group) throw new Error(`Missing checked expression group: ${part.group}`);
+          text.push("(");
+          if (!values.length) text.push(part.join === "AND" ? "TRUE" : "FALSE");
+          for (const [index, value] of values.entries()) {
+            if (!isRecord(value))
+              throw new Error(`Expected encoded expression record: ${part.repeat}`);
+            const tag = value._tag;
+            const branch = group.cases.find((candidate) => candidate.tag === tag);
+            if (!branch) throw new Error("Unknown checked expression case");
+            if (index) text.push(`
+${part.join}
+`);
+            text.push("(");
+            append(branch.parts, value);
+            text.push("\n)");
+          }
+          text.push("\n)");
+        }
+      }
+    };
+    append(program.root, input);
+    return { text: text.join(""), parameters };
+  };
+};
+
+// src/emit-native-json.ts
+var TEXT2 = codec("Text");
+var NATIVE_ARGUMENT = codec("NativePgJsonArgument");
+var reject2 = (message, start = 0, length = 1) => ({
+  ok: false,
+  diagnostics: [{ message, start, length, code: 30 }]
+});
+var NativeError = class extends Error {
+  start;
+  length;
+  constructor(message, start = 0, length = 1) {
+    super(message);
+    this.start = start;
+    this.length = length;
+  }
+};
+var family = [0, 16, 23, 20, 701, 1009, 1e3, 1007, 1016, 1022];
+var failure = Schema5.Struct({ code: Schema5.String, message: Schema5.String });
+var rowKey = (contract) => JSON.stringify(contract.row);
+var tokenText = (sql) => JSON.stringify([...sqlTokens(sql, "postgres")].map((token) => token.text));
+var DIRECTIVE = /^(?:\/\*|--)\s*@pg-(?:native|in)\b/u;
+var hasNativeJson = (source, dialect = "postgres") => [...sqlTokens(source, dialect, true)].some(
+  (token) => token.kind === "comment" && DIRECTIVE.test(token.text)
+);
+var parse = (source) => {
+  const comments = [...sqlTokens(source, "postgres", true)].filter((t) => t.kind === "comment");
+  const line = comments.find((t) => t.text.startsWith("--") && DIRECTIVE.test(t.text));
+  if (line)
+    throw new NativeError(
+      "Native directives must be block comments, such as /* @pg-native-json name */",
+      line.start,
+      line.end - line.start
+    );
+  const declarations = comments.filter((t) => /^\/\*\s*@pg-native-json\b/u.test(t.text));
+  if (declarations.length !== 1)
+    throw new NativeError(
+      "Exactly one @pg-native-json declaration is required",
+      declarations[1]?.start,
+      declarations[1] && declarations[1].end - declarations[1].start
+    );
+  const declaration = declarations[0];
+  const at = [declaration.start, declaration.end - declaration.start];
+  const match = /^\/\*\s*@pg-native-json\s+([A-Za-z_]\w*(?:\[\])?(?:\s+[A-Za-z_]\w*(?:\[\])?)*)\s*\*\/$/u.exec(
+    declaration.text
+  );
+  if (!match) throw new NativeError("Invalid @pg-native-json declaration", ...at);
+  const names = match[1].trim().split(/\s+/u);
+  if (new Set(names).size !== names.length)
+    throw new NativeError("Duplicate native argument declaration", ...at);
+  const lists = comments.filter((t) => /^\/\*\s*@pg-in\b/u.test(t.text));
+  if (lists.length > 1)
+    throw new NativeError(
+      "Only one independent @pg-in predicate is supported",
+      lists[1].start,
+      lists[1].end - lists[1].start
+    );
+  const marker = lists[0];
+  const listMatch = marker && /^\/\*\s*@pg-in\s+([A-Za-z_]\w*)\s+:([A-Za-z_]\w*)\s*\*\/$/u.exec(marker.text);
+  if (marker && !listMatch)
+    throw new NativeError("Invalid @pg-in predicate", marker.start, marker.end - marker.start);
+  const list = marker && listMatch ? { ...marker, column: listMatch[1], name: listMatch[2] } : void 0;
+  const scalar = names.filter((name) => !name.endsWith("[]"));
+  const listNames = names.filter((name) => name.endsWith("[]"));
+  if (listNames.length !== (list ? 1 : 0) || list && listNames[0] !== `${list.name}[]`)
+    throw new NativeError("Each @pg-in requires one matching name[] admission declaration", ...at);
+  if (list && scalar.length)
+    throw new NativeError("Native list and scalar admissions cannot be combined", ...at);
+  if (names.some((name) => /^(?:__proto__|constructor|prototype)(?:\[\])?$/u.test(name)))
+    throw new NativeError("Reserved native admission name", ...at);
+  if (comments.some((t) => /^\/\*\s*@(?:repeat|case|endcase)\b/u.test(t.text)))
+    throw new NativeError("Native admission cannot be mixed with boolean repeated expressions");
+  const program = list ? [
+    source.slice(0, list.start),
+    { in: { column: list.column, parameter: list.name } },
+    source.slice(list.end)
+  ] : [];
+  const alias = (index) => `__pg_native_${list.name}_${index}`;
+  const replacement = (count) => count ? ` ${list.column} IN (${Array.from({ length: count }, (_, i) => `:${alias(i)}`).join(",")}) ` : " 1=0 ";
+  const sample = (count) => list ? source.slice(0, list.start) + replacement(count) + source.slice(list.end) : source;
+  const locate = (count, diagnostic) => {
+    const message = diagnostic.message.replace(/__pg_native_([A-Za-z_]\w*?)_\d+\b/gu, "$1");
+    if (!list) return { ...diagnostic, message };
+    const replaced = replacement(count).length;
+    const shift = replaced - (list.end - list.start);
+    const origin = (offset, last) => offset < list.start ? offset : offset < list.start + replaced ? last ? list.end - 1 : list.start : offset - shift;
+    const start = origin(diagnostic.start, false);
+    const end = origin(diagnostic.start + Math.max(1, diagnostic.length) - 1, true);
+    return { ...diagnostic, message, start, length: Math.max(1, end - start + 1) };
+  };
+  return { source, scalar, list, alias, sample, locate, program };
+};
+var independent = (source, names) => {
+  const tokens2 = [...sqlTokens(source, "postgres")].map((t) => t.text);
+  while (tokens2.at(-1) === ";") tokens2.pop();
+  const upper = tokens2.map((t) => t.toUpperCase());
+  const identifier2 = (text) => /^[A-Za-z_]\w*$/u.test(text ?? "");
+  const parameters = (parts) => parts.flatMap((t, i) => t === ":" && parts[i + 1] ? [parts[i + 1]] : []);
+  const split = (parts) => {
+    const out = [[]];
+    let depth = 0;
+    for (const token of parts) {
+      if (token === "(") depth++;
+      if (token === ")") depth--;
+      if (token === "," && depth === 0) out.push([]);
+      else out.at(-1).push(token);
+    }
+    return out;
+  };
+  const close = (start) => {
+    let depth = 1;
+    for (let i = start + 1; i < tokens2.length; i++) {
+      if (tokens2[i] === "(") depth++;
+      if (tokens2[i] === ")" && --depth === 0) return i;
+    }
+    throw new Error("Unclosed native argument context");
+  };
+  const uses = /* @__PURE__ */ new Map();
+  const register = (name, context) => {
+    if (!names.includes(name)) return;
+    if (uses.has(name)) throw new Error("Each native argument requires one direct use");
+    uses.set(name, context);
+  };
+  const scalar = (term) => {
+    if (term.length === 1 && (/^(?:NULL|TRUE|FALSE|DEFAULT)$/iu.test(term[0]) || term[0].startsWith("'")))
+      return true;
+    if (term.every((t) => t.length === 1) && /^-?(?:\d+(?:\.\d*)?|\.\d+)$/u.test(term.join("")))
+      return true;
+    return /^: [A-Za-z_]\w*(?: : : (?:text|bigint|double precision))*$/iu.test(term.join(" "));
+  };
+  const setters = (parts, native) => {
+    for (const term of split(parts)) {
+      if (!identifier2(term[0]) || term[1] !== "=" || !scalar(term.slice(2)))
+        throw new Error("Native setters require a simple column and scalar");
+      for (const name of parameters(term))
+        if (names.includes(name)) {
+          if (!native || term.length !== 4 || term[2] !== ":")
+            throw new Error("Native UPDATE requires one direct setter");
+          register(name, `UPDATE ${term[0]}`);
+        }
+    }
+  };
+  if (upper[0] === "INSERT" && upper[1] === "INTO") {
+    const open = tokens2.indexOf("("), end = close(open), values = upper.indexOf("VALUES", end);
+    if (open !== 3 || !identifier2(tokens2[2]) || values !== end + 1 || tokens2[values + 1] !== "(")
+      throw new Error("Native INSERT requires one table and direct VALUES");
+    const valueEnd = close(values + 1);
+    const columns = split(tokens2.slice(open + 1, end)), terms = split(tokens2.slice(values + 2, valueEnd));
+    if (columns.length !== terms.length) throw new Error("Native INSERT arity differs");
+    columns.forEach((column, i) => {
+      if (column.length !== 1 || !identifier2(column[0]))
+        throw new Error("Native INSERT target must be a simple column");
+      const term = terms[i];
+      if (!scalar(term)) throw new Error("Native INSERT requires scalar terms");
+      for (const name of parameters(term))
+        if (names.includes(name)) {
+          if (term.length !== 2 || term[0] !== ":")
+            throw new Error("Native arguments cannot occur in expressions");
+          register(name, `INSERT ${column[0]}`);
+        }
+    });
+    if (valueEnd + 1 < tokens2.length) {
+      const conflict = valueEnd + 1;
+      if (upper[conflict] !== "ON" || upper[conflict + 1] !== "CONFLICT" || tokens2[conflict + 2] !== "(")
+        throw new Error("Additional VALUES rows or INSERT suffixes are unsupported");
+      const conflictEnd = close(conflict + 2);
+      if (!split(tokens2.slice(conflict + 3, conflictEnd)).every(
+        (column) => column.length === 1 && identifier2(column[0])
+      ) || upper[conflictEnd + 1] !== "DO" || upper[conflictEnd + 2] !== "UPDATE" || upper[conflictEnd + 3] !== "SET")
+        throw new Error("Native conflict requires a simple column target and direct setters");
+      setters(tokens2.slice(conflictEnd + 4), false);
+    }
+  } else if (upper[0] === "UPDATE") {
+    const set = upper.indexOf("SET"), where = upper.indexOf("WHERE", set);
+    if (set !== 2 || !identifier2(tokens2[1]) || where < 0)
+      throw new Error("Native UPDATE requires one table, SET and WHERE");
+    setters(tokens2.slice(set + 1, where), true);
+    const predicate = tokens2.slice(where + 1);
+    if (predicate.length !== 4 || !identifier2(predicate[0]) || predicate[1] !== "=" || predicate[2] !== ":" || !identifier2(predicate[3]))
+      throw new Error("Native UPDATE requires a direct key predicate");
+  } else if (upper[0] === "SELECT") {
+    const from = upper.indexOf("FROM"), where = upper.indexOf("WHERE");
+    if (from < 0 || where !== from + 2 || !identifier2(tokens2[from + 1]) || !split(tokens2.slice(1, from)).every((column) => column.length === 1 && identifier2(column[0])))
+      throw new Error(
+        "Native IN requires a plain column SELECT from one table; aggregates, windows and expressions are unsupported"
+      );
+    const body = tokens2.slice(where + 1);
+    const members = names.flatMap((name, i) => i ? [",", ":", name] : [":", name]);
+    const expected = [body[0], "IN", "(", ...members, ")"];
+    const suffix = body.slice(expected.length);
+    if (!/^[A-Za-z_]\w*$/u.test(body[0] ?? "") || suffix.length && (suffix.length !== 4 || suffix[0]?.toUpperCase() !== "AND" || !/^[A-Za-z_]\w*$/u.test(suffix[1] ?? "") || suffix[2]?.toUpperCase() !== "IS" || suffix[3]?.toUpperCase() !== "NULL"))
+      throw new Error(
+        "Native list context must be an isolated IN predicate with an optional IS NULL filter"
+      );
+    expected.push(...suffix);
+    if (JSON.stringify(body.map((t) => t.toUpperCase())) !== JSON.stringify(expected.map((t) => t.toUpperCase())))
+      throw new Error("Native list context must be an isolated IN predicate");
+    for (const name of names) register(name, `${body[0]} IN member`);
+  } else throw new Error("Unsupported native admission statement context");
+  for (const name of names)
+    if (!uses.has(name) || parameters(tokens2).filter((n) => n === name).length !== 1)
+      throw new Error(`Unsupported or repeated native argument :${name}`);
+  return Object.fromEntries(uses);
+};
+var DescribeKey = class _DescribeKey {
+  id;
+  run;
+  constructor(id, run2) {
+    this.id = id;
+    this.run = run2;
+  }
+  [Equal.symbol](that) {
+    return that instanceof _DescribeKey && that.id === this.id;
+  }
+  [Hash.symbol]() {
+    return Hash.string(this.id);
+  }
+};
+var repeats = (exit) => Exit2.isSuccess(exit) && (exit.value.ok || Option5.isSome(exit.value.error));
+var descriptions = Effect6.runSync(
+  Cache.makeWith((key) => key.run, {
+    capacity: 4096,
+    timeToLive: (exit) => repeats(exit) ? Duration.infinity : Duration.zero
+  })
+);
+var describeOnce = (describe, entry, sql, oids) => {
+  const run2 = Effect6.map(
+    Effect6.result(describe(sql, oids)),
+    (described) => Result2.isSuccess(described) ? { ok: true, columns: described.success.columns } : {
+      ok: false,
+      message: described.failure.message,
+      error: Schema5.decodeUnknownOption(failure)(described.failure.cause)
+    }
+  );
+  if (entry === void 0) return run2;
+  return Cache.get(descriptions, new DescribeKey(`${entry}\0${oids.join(",")}`, run2));
+};
+var nativeJsonContract = (source, owned) => withEntry((seen) => checkNative(source, owned, seen));
+var checkNative = Effect6.fn("Emit.nativeJsonContract")(function* (source, owned, seen) {
+  if (owned.project.dialect !== "postgres")
+    return reject2("Native JSON arguments require PostgreSQL");
+  const describe = owned.describeParameters;
+  if (!describe)
+    return reject2(
+      "Native JSON arguments require schema-file PostgreSQL analysis with explicit OID support"
+    );
+  const parsed = yield* Effect6.result(
+    Effect6.try({
+      try: () => parse(source),
+      catch: (e) => e instanceof NativeError ? e : new NativeError("Invalid native declaration")
+    })
+  );
+  if (Result2.isFailure(parsed))
+    return reject2(parsed.failure.message, parsed.failure.start, parsed.failure.length);
+  const query = parsed.success;
+  const contracts = [];
+  const admissions = [];
+  for (const count of query.list ? [0, 1, 2] : [1]) {
+    const sql = query.sample(count);
+    const names = query.list ? Array.from({ length: count }, (_, i) => query.alias(i)) : query.scalar;
+    if (count) {
+      const proof = yield* Effect6.result(
+        Effect6.try({
+          try: () => independent(sql, names),
+          catch: (e) => e instanceof Error ? e.message : "Invalid native use"
+        })
+      );
+      if (Result2.isFailure(proof)) return reject2(proof.failure);
+    }
+    const mapped = yield* analyzeContract(sql, owned);
+    seen.entry = mapped.entry ?? seen.entry;
+    if (!mapped.ok)
+      return {
+        ok: false,
+        diagnostics: mapped.diagnostics.map((diagnostic) => query.locate(count, diagnostic))
+      };
+    const contract = mapped.value;
+    if (query.list) {
+      const sent = statementCompiler({ root: query.program, groups: [] })({
+        [query.list.name]: Array.from({ length: count }, () => null)
+      });
+      if (tokenText(sent.text) !== tokenText(contract.sql))
+        return reject2("Native IN does not support SQL requiring structural parameter rewrites");
+    }
+    contracts.push(contract);
+    for (const name of names) {
+      const field = contract.input.find((f) => f.name === name);
+      if (!field || !admits(nullOr(TEXT2), field.schema))
+        return reject2(
+          `Native argument :${query.list ? query.list.name : name} must have an analyzed TEXT context`
+        );
+    }
+    const baseline = yield* describeOnce(
+      describe,
+      mapped.entry,
+      contract.sql,
+      contract.order.map(() => 0)
+    );
+    if (!baseline.ok) return reject2(baseline.message);
+    const columnKey = JSON.stringify(baseline.columns);
+    const vectors = query.list && count === 2 ? family.flatMap((first) => family.map((second) => [first, second])) : names.flatMap((name) => family.map((oid) => ({ name, oid })));
+    for (const variant of vectors) {
+      const oids = Array.isArray(variant) ? contract.order.map((name) => variant[names.indexOf(name)] ?? 0) : contract.order.map((name) => name === variant.name ? variant.oid : 0);
+      if (oids.every((oid) => oid === 0)) continue;
+      const described = yield* describeOnce(describe, mapped.entry, contract.sql, oids);
+      if (!described.ok) {
+        if (!query.list || Option5.isNone(described.error) || described.error.value.code !== "42883")
+          return reject2(`Native OID variant is unsupported: ${described.message}`);
+        admissions.push({ oids, code: described.error.value.code });
+      } else {
+        if (query.list) return reject2("Native IN gained an unexpected non-TEXT success variant");
+        if (JSON.stringify(described.columns) !== columnKey)
+          return reject2("Native OID alternatives change the result contract");
+        admissions.push({ oids, code: null });
+      }
+    }
+  }
+  const base = contracts.at(-1);
+  const returning = query.list ? contracts.slice(1) : contracts;
+  if (returning.some((contract) => rowKey(contract) !== rowKey(base)))
+    return reject2("Native list changes the analyzed Row contract");
+  const aliases = query.list ? [0, 1].map(query.alias) : [];
+  const input = base.input.filter((field) => !aliases.includes(field.name)).map(
+    (field) => query.scalar.includes(field.name) ? { ...field, schema: NATIVE_ARGUMENT, optional: true } : field
+  );
+  if (query.list) input.push({ name: query.list.name, schema: arrayOf(NATIVE_ARGUMENT) });
+  const value = {
+    ...base,
+    identity: sha2562(source),
+    input,
+    order: query.list ? input.map((field) => field.name) : base.order,
+    cardinality: query.list ? "many" : base.cardinality,
+    program: query.list ? { root: query.program, groups: [] } : void 0,
+    // The checked OID outcomes, by SQLSTATE: server wording does not change the contract.
+    contractHash: sha2562(
+      JSON.stringify([
+        base.contractHash,
+        source,
+        input.map((field) => hashedField(field)),
+        query.program,
+        admissions,
+        "pg-native-json/2"
+      ])
+    )
+  };
+  return { ok: true, value };
+});
+
+// src/emit.ts
+var releaseAnalysis = exclusive(releaseConnections);
+var emitModule = (path, sql, session) => exclusive(
+  Effect7.gen(function* () {
+    const owned = session ?? (yield* Session.for(dirname4(path)));
+    yield* owned.recheck;
+    const emitted = yield* emitModuleExclusive(path, sql, owned);
+    return { ...emitted, watchDirs: yield* watchDirectories(owned.project) };
+  })
+);
+var emitModuleExclusive = Effect7.fn("Emit.module")(function* (path, sql, owned) {
+  const watch = yield* watchFiles(owned.project);
+  const dialect = owned.project.dialect;
+  const contract = hasNativeJson(sql, dialect) ? yield* nativeJsonContract(sql, owned) : yield* ordinaryContract(sql, owned);
+  if (!contract.ok)
+    return fail(
+      contract.diagnostics.map((diagnostic) => diagnostic.message).join("\n"),
+      contract.diagnostics,
+      watch,
+      contract.entry
+    );
+  return {
+    ok: true,
+    code: render(path, contract.value),
+    diagnostics: [],
+    entry: contract.entry,
+    watch
+  };
+});
+var ordinaryContract = Effect7.fn("Emit.ordinaryContract")(function* (sql, owned) {
+  const repeated = parseRepeatedSql(sql, owned.project.dialect);
+  if (!repeated.ok) return { ...repeated, entry: void 0 };
+  if (repeated.value !== void 0) return yield* repeatedContract(repeated.value, owned);
+  return yield* analyzeContract(sql, owned);
+});
+function fail(message, diagnostics, watch, entry) {
+  return {
+    ok: false,
+    code: unsupportedModule(message),
+    diagnostics,
+    entry,
+    watch
+  };
+}
+function unsupportedModule(message) {
+  return [
+    `import { Effect, Schema } from "effect";`,
+    ``,
+    `export const Input = Schema.Never;`,
+    `export const Row = Schema.Never;`,
+    ``,
+    `export default function unsupported(_input: never): Effect.Effect<never> {`,
+    `  return Effect.die(new Error(${JSON.stringify(message)}));`,
+    `}`,
+    ``
+  ].join("\n");
+}
+var watchFiles = Effect7.fn("Emit.watchFiles")(function* (project) {
+  const watch = [...project.watched];
+  if (project.schema !== void 0) {
+    watch.push(...(yield* schemaFiles(project.root, project.schema)).files);
+  }
+  if (project.dialect === "sqlite" && project.url !== void 0 && project.schema === void 0) {
+    const database = sqlitePath(project.url, project.root);
+    if (database !== ":memory:" && !watch.includes(database)) watch.push(database);
+  }
+  return [...new Set(watch)];
+});
+var watchDirectories = Effect7.fn("Emit.watchDirectories")(function* (project) {
+  const fs = yield* FileSystem3.FileSystem;
+  const directories = /* @__PURE__ */ new Set();
+  for (const pattern of project.schema ?? []) {
+    const magic = pattern.search(/[*?[\]{}()\\]|^!/u);
+    if (magic < 0) {
+      directories.add(dirname4(resolve3(project.root, pattern)));
+      continue;
+    }
+    const prefix = pattern.slice(0, magic);
+    const root = resolve3(project.root, prefix.slice(0, prefix.lastIndexOf("/") + 1) || ".");
+    directories.add(dirname4(root));
+    const visit = (directory) => Effect7.gen(function* () {
+      directories.add(directory);
+      const entries = yield* fs.readDirectory(directory);
+      for (const name of entries) {
+        if (name === "node_modules" || name === ".git") continue;
+        const child = join6(directory, name);
+        const info = yield* Effect7.option(fs.stat(child));
+        if (Option6.isSome(info) && info.value.type === "Directory") yield* visit(child);
+      }
+    }).pipe(
+      // A root that does not exist yet is still watched, so its creation is seen.
+      Effect7.catchReason("PlatformError", "NotFound", () => Effect7.void)
+    );
+    yield* visit(root);
+  }
+  return [...directories];
+});
+
+// src/esbuild.ts
+import { host } from "./host.js";
+function place2(text, bytes2) {
+  const before = Buffer.from(text, "utf8").subarray(0, Math.max(0, bytes2)).toString("utf8");
+  const line = before.split("\n").length;
+  const column = before.length - before.lastIndexOf("\n");
+  return `${line}:${column}`;
+}
+var load = Effect8.fn("Esbuild.load")(function* (path) {
+  const fs = yield* FileSystem4.FileSystem;
+  const sql = yield* fs.readFileString(path);
+  const emitted = yield* emitModule(path, sql);
+  const watchFiles2 = [
+    path,
+    ...emitted.entry === void 0 ? [] : [emitted.entry],
+    ...emitted.watch
+  ];
+  const watchDirs = [...emitted.watchDirs ?? []];
+  if (!emitted.ok) {
+    const details = emitted.diagnostics.map((diagnostic) => `${path}:${place2(sql, diagnostic.start)}: ${diagnostic.message}`).join("\n");
+    return { errors: [{ text: details }], watchFiles: watchFiles2, watchDirs };
+  }
+  return { contents: emitted.code, loader: "js", watchFiles: watchFiles2, watchDirs };
+});
+function reyloEffect() {
+  return {
+    name: "reylo-effect",
+    setup(build) {
+      build.onLoad({ filter: /\.sql$/ }, (args) => host.runPromise(load(args.path)));
+      build.onEnd(() => host.runPromise(releaseAnalysis));
+    }
+  };
+}
+export {
+  reyloEffect as default
+};