@mateusseiboth/ember-orm 0.1.0

package/dist/index.js

@@ -0,0 +1,4935 @@
+// src/ast/index.ts
+var SCALAR_TYPES = [
+  "String",
+  "Boolean",
+  "Int",
+  "BigInt",
+  "Float",
+  "Decimal",
+  "DateTime",
+  "Bytes",
+  "Json"
+];
+function emptySchema() {
+  return { generators: [], models: [], enums: [] };
+}
+function findModel(schema, name) {
+  return schema.models.find((m) => m.name === name);
+}
+function findEnum(schema, name) {
+  return schema.enums.find((e) => e.name === name);
+}
+function fieldColumn(field) {
+  return field.dbName ?? field.name.toUpperCase();
+}
+function modelTable(model) {
+  return model.dbName ?? model.name.toUpperCase();
+}
+function scalarFields(model) {
+  return model.fields.filter((f) => f.kind !== "object");
+}
+function relationFields(model) {
+  return model.fields.filter((f) => f.kind === "object");
+}
+function idFields(model) {
+  if (model.primaryKey.length > 0) {
+    return model.primaryKey.map((n) => model.fields.find((f) => f.name === n)).filter((f) => !!f);
+  }
+  return model.fields.filter((f) => f.isId);
+}
+
+// src/schema/index.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+
+// src/errors/index.ts
+var EmberError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var SchemaParseError = class extends EmberError {
+  constructor(message, line, column, file) {
+    super(
+      `${message} (at ${file ? `${file}:` : ""}${line}:${column})`
+    );
+    this.line = line;
+    this.column = column;
+    this.file = file;
+  }
+  line;
+  column;
+  file;
+};
+var SchemaValidationError = class extends EmberError {
+  constructor(message, details = []) {
+    super(
+      details.length > 0 ? `${message}
+ - ${details.join("\n - ")}` : message
+    );
+    this.details = details;
+  }
+  details;
+};
+var QueryValidationError = class extends EmberError {
+};
+var DatabaseError = class extends EmberError {
+  constructor(message, cause, sql) {
+    super(message);
+    this.cause = cause;
+    this.sql = sql;
+  }
+  cause;
+  sql;
+};
+var RecordNotFoundError = class extends EmberError {
+  constructor(model) {
+    super(`No '${model}' record found matching the given criteria.`);
+  }
+};
+var UniqueConstraintError = class extends EmberError {
+  constructor(target, cause) {
+    super(`Unique constraint failed on: ${target}`);
+    this.target = target;
+    if (cause !== void 0) this.cause = cause;
+  }
+  target;
+};
+
+// src/schema/lexer.ts
+var SINGLE_CHAR_TOKENS = {
+  "{": "lbrace",
+  "}": "rbrace",
+  "(": "lparen",
+  ")": "rparen",
+  "[": "lbracket",
+  "]": "rbracket",
+  "=": "equals",
+  ",": "comma",
+  ":": "colon",
+  "?": "question",
+  ".": "dot"
+};
+var IDENT_START = /[A-Za-z_]/;
+var IDENT_PART = /[A-Za-z0-9_]/;
+var Lexer = class {
+  constructor(source, file) {
+    this.source = source;
+    this.file = file;
+  }
+  source;
+  file;
+  pos = 0;
+  line = 1;
+  column = 1;
+  tokenize() {
+    const tokens = [];
+    let token = this.next();
+    while (token.type !== "eof") {
+      tokens.push(token);
+      token = this.next();
+    }
+    tokens.push(token);
+    return tokens;
+  }
+  next() {
+    this.skipWhitespaceAndComments();
+    if (this.pos >= this.source.length) {
+      return this.make("eof", "");
+    }
+    const startLine = this.line;
+    const startColumn = this.column;
+    const ch = this.source[this.pos];
+    if (ch === "/" && this.peek(1) === "/" && this.peek(2) === "/") {
+      return this.readDocComment(startLine, startColumn);
+    }
+    if (ch === '"') {
+      return this.readString(startLine, startColumn);
+    }
+    if (ch === "@") {
+      this.advance();
+      if (this.source[this.pos] === "@") {
+        this.advance();
+        return { type: "double_at", value: "@@", line: startLine, column: startColumn };
+      }
+      return { type: "at", value: "@", line: startLine, column: startColumn };
+    }
+    const single = SINGLE_CHAR_TOKENS[ch];
+    if (single) {
+      this.advance();
+      return { type: single, value: ch, line: startLine, column: startColumn };
+    }
+    if (ch === "-" || /[0-9]/.test(ch)) {
+      return this.readNumber(startLine, startColumn);
+    }
+    if (IDENT_START.test(ch)) {
+      return this.readIdentifier(startLine, startColumn);
+    }
+    throw new SchemaParseError(
+      `Unexpected character '${ch}'`,
+      startLine,
+      startColumn,
+      this.file
+    );
+  }
+  readDocComment(line, column) {
+    this.advance();
+    this.advance();
+    this.advance();
+    let value = "";
+    while (this.pos < this.source.length && this.source[this.pos] !== "\n") {
+      value += this.source[this.pos];
+      this.advance();
+    }
+    return { type: "doc_comment", value: value.trim(), line, column };
+  }
+  readString(line, column) {
+    this.advance();
+    let value = "";
+    while (this.pos < this.source.length && this.source[this.pos] !== '"') {
+      const c = this.source[this.pos];
+      if (c === "\\") {
+        this.advance();
+        const escaped = this.source[this.pos];
+        if (escaped === void 0) break;
+        value += escapeChar(escaped);
+        this.advance();
+        continue;
+      }
+      if (c === "\n") {
+        throw new SchemaParseError(
+          "Unterminated string literal",
+          line,
+          column,
+          this.file
+        );
+      }
+      value += c;
+      this.advance();
+    }
+    if (this.source[this.pos] !== '"') {
+      throw new SchemaParseError(
+        "Unterminated string literal",
+        line,
+        column,
+        this.file
+      );
+    }
+    this.advance();
+    return { type: "string", value, line, column };
+  }
+  readNumber(line, column) {
+    let value = "";
+    if (this.source[this.pos] === "-") {
+      value += "-";
+      this.advance();
+    }
+    while (this.pos < this.source.length && /[0-9.]/.test(this.source[this.pos])) {
+      value += this.source[this.pos];
+      this.advance();
+    }
+    return { type: "number", value, line, column };
+  }
+  readIdentifier(line, column) {
+    let value = "";
+    while (this.pos < this.source.length && IDENT_PART.test(this.source[this.pos])) {
+      value += this.source[this.pos];
+      this.advance();
+    }
+    return { type: "identifier", value, line, column };
+  }
+  skipWhitespaceAndComments() {
+    while (this.pos < this.source.length) {
+      const ch = this.source[this.pos];
+      if (ch === " " || ch === "	" || ch === "\r" || ch === "\n") {
+        this.advance();
+        continue;
+      }
+      if (ch === "/" && this.peek(1) === "/" && this.peek(2) !== "/") {
+        while (this.pos < this.source.length && this.source[this.pos] !== "\n") {
+          this.advance();
+        }
+        continue;
+      }
+      if (ch === "/" && this.peek(1) === "*") {
+        this.advance();
+        this.advance();
+        while (this.pos < this.source.length && !(this.source[this.pos] === "*" && this.peek(1) === "/")) {
+          this.advance();
+        }
+        this.advance();
+        this.advance();
+        continue;
+      }
+      break;
+    }
+  }
+  peek(offset) {
+    return this.source[this.pos + offset];
+  }
+  advance() {
+    if (this.source[this.pos] === "\n") {
+      this.line++;
+      this.column = 1;
+    } else {
+      this.column++;
+    }
+    this.pos++;
+  }
+  make(type, value) {
+    return { type, value, line: this.line, column: this.column };
+  }
+};
+function escapeChar(c) {
+  switch (c) {
+    case "n":
+      return "\n";
+    case "t":
+      return "	";
+    case "r":
+      return "\r";
+    case '"':
+      return '"';
+    case "\\":
+      return "\\";
+    default:
+      return c;
+  }
+}
+
+// src/schema/parser.ts
+var Parser = class {
+  constructor(source, file) {
+    this.file = file;
+    this.tokens = new Lexer(source, file).tokenize();
+  }
+  file;
+  tokens;
+  pos = 0;
+  parse() {
+    const doc = { generators: [], models: [], enums: [] };
+    let pendingDoc = [];
+    while (!this.isEof()) {
+      const tok = this.peek();
+      if (tok.type === "doc_comment") {
+        pendingDoc.push(tok.value);
+        this.advance();
+        continue;
+      }
+      if (tok.type !== "identifier") {
+        throw this.error(`Unexpected token '${tok.value}'`, tok);
+      }
+      const documentation = pendingDoc.length ? pendingDoc.join("\n") : void 0;
+      pendingDoc = [];
+      switch (tok.value) {
+        case "datasource":
+          doc.datasource = this.parseDatasource();
+          break;
+        case "generator":
+          doc.generators.push(this.parseGenerator());
+          break;
+        case "model":
+          doc.models.push(this.parseModel(documentation));
+          break;
+        case "enum":
+          doc.enums.push(this.parseEnum(documentation));
+          break;
+        default:
+          throw this.error(`Unknown top-level keyword '${tok.value}'`, tok);
+      }
+    }
+    resolveKinds(doc);
+    return doc;
+  }
+  // ---- Top-level blocks -------------------------------------------------
+  parseDatasource() {
+    this.expectKeyword("datasource");
+    const name = this.expect("identifier").value;
+    this.expect("lbrace");
+    const assignments = this.parseAssignments();
+    this.expect("rbrace");
+    const provider = literalString(assignments["provider"]);
+    const urlAssign = assignments["url"];
+    let url = { kind: "literal", value: "" };
+    if (urlAssign) {
+      if (urlAssign.kind === "function" && urlAssign.name === "env") {
+        url = { kind: "env", value: literalString(urlAssign.args[0]) };
+      } else if (urlAssign.kind === "string") {
+        url = { kind: "literal", value: urlAssign.value };
+      }
+    }
+    return { name, provider: provider ?? "firebird", url };
+  }
+  parseGenerator() {
+    this.expectKeyword("generator");
+    const name = this.expect("identifier").value;
+    this.expect("lbrace");
+    const assignments = this.parseAssignments();
+    this.expect("rbrace");
+    const config = {};
+    for (const [key, value] of Object.entries(assignments)) {
+      if (value.kind === "string") config[key] = value.value;
+    }
+    return {
+      name,
+      provider: literalString(assignments["provider"]) ?? "ember-client-js",
+      output: assignments["output"] ? literalString(assignments["output"]) : void 0,
+      config
+    };
+  }
+  parseAssignments() {
+    const out = {};
+    while (!this.check("rbrace") && !this.isEof()) {
+      if (this.check("doc_comment")) {
+        this.advance();
+        continue;
+      }
+      const key = this.expect("identifier").value;
+      this.expect("equals");
+      out[key] = this.parseValue();
+    }
+    return out;
+  }
+  parseModel(documentation) {
+    this.expectKeyword("model");
+    const name = this.expect("identifier").value;
+    this.expect("lbrace");
+    const model = {
+      name,
+      fields: [],
+      primaryKey: [],
+      uniqueIndexes: [],
+      indexes: [],
+      documentation
+    };
+    let pendingDoc = [];
+    while (!this.check("rbrace") && !this.isEof()) {
+      const tok = this.peek();
+      if (tok.type === "doc_comment") {
+        pendingDoc.push(tok.value);
+        this.advance();
+        continue;
+      }
+      if (tok.type === "double_at") {
+        this.parseBlockAttribute(model);
+        pendingDoc = [];
+        continue;
+      }
+      const field = this.parseField(
+        pendingDoc.length ? pendingDoc.join("\n") : void 0
+      );
+      pendingDoc = [];
+      model.fields.push(field);
+      if (field.isId && !model.primaryKey.includes(field.name)) {
+        model.primaryKey.push(field.name);
+      }
+    }
+    this.expect("rbrace");
+    return model;
+  }
+  parseField(documentation) {
+    const name = this.expect("identifier").value;
+    const typeName = this.expect("identifier").value;
+    let isList = false;
+    let isRequired = true;
+    while (this.check("lbracket") || this.check("question")) {
+      if (this.check("lbracket")) {
+        this.advance();
+        this.expect("rbracket");
+        isList = true;
+      } else {
+        this.advance();
+        isRequired = false;
+      }
+    }
+    const field = {
+      name,
+      type: typeName,
+      kind: "scalar",
+      // resolved later
+      isList,
+      isRequired,
+      isId: false,
+      isUnique: false,
+      isUpdatedAt: false,
+      documentation
+    };
+    while (this.check("at")) {
+      const attr = this.parseAttribute();
+      this.applyFieldAttribute(field, attr);
+    }
+    return field;
+  }
+  applyFieldAttribute(field, attr) {
+    if (attr.name.startsWith("db.")) {
+      field.nativeType = toNativeType(attr);
+      return;
+    }
+    switch (attr.name) {
+      case "id":
+        field.isId = true;
+        break;
+      case "unique":
+        field.isUnique = true;
+        break;
+      case "updatedAt":
+        field.isUpdatedAt = true;
+        break;
+      case "default":
+        field.default = toDefaultValue(attr.args[0]);
+        break;
+      case "map":
+        field.dbName = literalString(attr.args[0]);
+        break;
+      case "relation":
+        field.relation = toRelationInfo(attr.args);
+        break;
+      default:
+        throw this.error(`Unknown field attribute '@${attr.name}'`, attr);
+    }
+  }
+  parseBlockAttribute(model) {
+    const start = this.expect("double_at");
+    const name = this.expect("identifier").value;
+    const args = this.check("lparen") ? this.parseArgList() : [];
+    switch (name) {
+      case "id":
+        model.primaryKey = fieldNameList(args);
+        break;
+      case "unique":
+        model.uniqueIndexes.push({
+          fields: fieldNameList(args),
+          name: namedArg(args, "map")
+        });
+        break;
+      case "index":
+        model.indexes.push({
+          fields: fieldNameList(args),
+          name: namedArg(args, "map"),
+          unique: false
+        });
+        break;
+      case "map":
+        model.dbName = literalString(args[0]);
+        break;
+      default:
+        throw this.error(`Unknown block attribute '@@${name}'`, start);
+    }
+  }
+  parseEnum(documentation) {
+    this.expectKeyword("enum");
+    const name = this.expect("identifier").value;
+    this.expect("lbrace");
+    const node = { name, values: [], documentation };
+    while (!this.check("rbrace") && !this.isEof()) {
+      if (this.check("doc_comment")) {
+        this.advance();
+        continue;
+      }
+      if (this.check("double_at")) {
+        this.advance();
+        const attrName = this.expect("identifier").value;
+        const args = this.check("lparen") ? this.parseArgList() : [];
+        if (attrName === "map") node.dbName = literalString(args[0]);
+        continue;
+      }
+      const valueName = this.expect("identifier").value;
+      let dbName;
+      while (this.check("at")) {
+        const attr = this.parseAttribute();
+        if (attr.name === "map") dbName = literalString(attr.args[0]);
+      }
+      node.values.push({ name: valueName, dbName });
+    }
+    this.expect("rbrace");
+    return node;
+  }
+  // ---- Attributes & values ---------------------------------------------
+  parseAttribute() {
+    const at = this.expect("at");
+    let name = this.expect("identifier").value;
+    if (this.check("dot")) {
+      this.advance();
+      name += "." + this.expect("identifier").value;
+    }
+    const args = this.check("lparen") ? this.parseArgList() : [];
+    return { name, args, line: at.line, column: at.column };
+  }
+  parseArgList() {
+    this.expect("lparen");
+    const args = [];
+    while (!this.check("rparen") && !this.isEof()) {
+      args.push(this.parseArg());
+      if (this.check("comma")) this.advance();
+    }
+    this.expect("rparen");
+    return args;
+  }
+  /** Handles both positional values and `name: value` named arguments. */
+  parseArg() {
+    if (this.check("identifier") && this.peek(1)?.type === "colon") {
+      const key = this.expect("identifier").value;
+      this.expect("colon");
+      const value = this.parseValue();
+      return { kind: "function", name: `__named:${key}`, args: [value] };
+    }
+    return this.parseValue();
+  }
+  parseValue() {
+    const tok = this.peek();
+    switch (tok.type) {
+      case "string":
+        this.advance();
+        return { kind: "string", value: tok.value };
+      case "number":
+        this.advance();
+        return { kind: "number", value: Number(tok.value) };
+      case "lbracket": {
+        this.advance();
+        const items = [];
+        while (!this.check("rbracket") && !this.isEof()) {
+          items.push(this.parseValue());
+          if (this.check("comma")) this.advance();
+        }
+        this.expect("rbracket");
+        return { kind: "array", items };
+      }
+      case "identifier": {
+        this.advance();
+        if (tok.value === "true" || tok.value === "false") {
+          return { kind: "boolean", value: tok.value === "true" };
+        }
+        if (this.check("lparen")) {
+          const args = this.parseArgList();
+          return { kind: "function", name: tok.value, args };
+        }
+        return { kind: "ref", value: tok.value };
+      }
+      default:
+        throw this.error(`Unexpected value token '${tok.value}'`, tok);
+    }
+  }
+  // ---- Token helpers ----------------------------------------------------
+  peek(offset = 0) {
+    return this.tokens[this.pos + offset] ?? this.tokens[this.tokens.length - 1];
+  }
+  advance() {
+    const tok = this.tokens[this.pos];
+    if (this.pos < this.tokens.length - 1) this.pos++;
+    return tok;
+  }
+  check(type) {
+    return this.peek().type === type;
+  }
+  isEof() {
+    return this.peek().type === "eof";
+  }
+  expect(type) {
+    const tok = this.peek();
+    if (tok.type !== type) {
+      throw this.error(`Expected ${type} but found '${tok.value}' (${tok.type})`, tok);
+    }
+    return this.advance();
+  }
+  expectKeyword(keyword) {
+    const tok = this.peek();
+    if (tok.type !== "identifier" || tok.value !== keyword) {
+      throw this.error(`Expected keyword '${keyword}'`, tok);
+    }
+    return this.advance();
+  }
+  error(message, at) {
+    return new SchemaParseError(message, at.line, at.column, this.file);
+  }
+};
+function literalString(v) {
+  if (!v) return "";
+  if (v.kind === "string") return v.value;
+  if (v.kind === "ref") return v.value;
+  return String("value" in v ? v.value : "");
+}
+function toNativeType(attr) {
+  const name = attr.name.slice("db.".length);
+  const args = attr.args.filter((a) => a.kind === "number").map((a) => a.value);
+  return { name, args };
+}
+function toDefaultValue(v) {
+  if (!v) return {};
+  switch (v.kind) {
+    case "function":
+      return { function: { name: v.name, args: v.args } };
+    case "string":
+      return { literal: v.value };
+    case "number":
+      return { literal: v.value };
+    case "boolean":
+      return { literal: v.value };
+    case "ref":
+      return { literal: v.value };
+    default:
+      return {};
+  }
+}
+function toRelationInfo(args) {
+  const info = {};
+  for (const arg of args) {
+    if (arg.kind === "string") {
+      info.name = arg.value;
+      continue;
+    }
+    const named = asNamed(arg);
+    if (!named) continue;
+    const [key, value] = named;
+    if (key === "name" && value.kind === "string") info.name = value.value;
+    if (key === "fields") info.fields = refArray(value);
+    if (key === "references") info.references = refArray(value);
+    if (key === "onDelete") info.onDelete = refName(value);
+    if (key === "onUpdate") info.onUpdate = refName(value);
+  }
+  return info;
+}
+function asNamed(arg) {
+  if (arg.kind === "function" && arg.name.startsWith("__named:")) {
+    return [arg.name.slice("__named:".length), arg.args[0]];
+  }
+  return void 0;
+}
+function namedArg(args, key) {
+  for (const arg of args) {
+    const named = asNamed(arg);
+    if (named && named[0] === key && named[1].kind === "string") {
+      return named[1].value;
+    }
+  }
+  return void 0;
+}
+function refArray(v) {
+  if (v.kind === "array") {
+    return v.items.map((i) => refName(i)).filter((s) => !!s);
+  }
+  const single = refName(v);
+  return single ? [single] : [];
+}
+function refName(v) {
+  if (v.kind === "ref") return v.value;
+  if (v.kind === "string") return v.value;
+  return void 0;
+}
+function fieldNameList(args) {
+  for (const arg of args) {
+    if (arg.kind === "array") return refArray(arg);
+    const named = asNamed(arg);
+    if (named && named[0] === "fields") return refArray(named[1]);
+  }
+  return args.map((a) => refName(a)).filter((s) => !!s);
+}
+function resolveKinds(doc) {
+  const modelNames = new Set(doc.models.map((m) => m.name));
+  const enumNames = new Set(doc.enums.map((e) => e.name));
+  for (const model of doc.models) {
+    for (const field of model.fields) {
+      if (modelNames.has(field.type)) field.kind = "object";
+      else if (enumNames.has(field.type)) field.kind = "enum";
+      else field.kind = "scalar";
+    }
+  }
+}
+
+// src/schema/validator.ts
+function validateSchema(doc) {
+  const errors = [];
+  const scalar = new Set(SCALAR_TYPES);
+  const enumNames = new Set(doc.enums.map((e) => e.name));
+  const modelNames = new Set(doc.models.map((m) => m.name));
+  const duplicateModels = findDuplicates(doc.models.map((m) => m.name));
+  for (const name of duplicateModels) {
+    errors.push(`Duplicate model '${name}'.`);
+  }
+  for (const model of doc.models) {
+    const fieldNames = /* @__PURE__ */ new Set();
+    for (const field of model.fields) {
+      if (fieldNames.has(field.name)) {
+        errors.push(`Duplicate field '${model.name}.${field.name}'.`);
+      }
+      fieldNames.add(field.name);
+      const known = scalar.has(field.type) || enumNames.has(field.type) || modelNames.has(field.type);
+      if (!known) {
+        errors.push(
+          `Field '${model.name}.${field.name}' has unknown type '${field.type}'.`
+        );
+      }
+      if (field.kind === "object" && field.relation) {
+        validateRelation(doc, model.name, field.name, field.relation, errors);
+      }
+    }
+    for (const pk of model.primaryKey) {
+      if (!fieldNames.has(pk)) {
+        errors.push(
+          `Primary key field '${pk}' does not exist on model '${model.name}'.`
+        );
+      }
+    }
+    const hasId = model.primaryKey.length > 0 || model.fields.some((f) => f.isId);
+    if (!hasId) {
+      errors.push(
+        `Model '${model.name}' has no @id / @@id. Every model needs a primary key.`
+      );
+    }
+  }
+  for (const enumNode of doc.enums) {
+    if (enumNode.values.length === 0) {
+      errors.push(`Enum '${enumNode.name}' has no values.`);
+    }
+  }
+  if (errors.length > 0) {
+    throw new SchemaValidationError("Schema validation failed", errors);
+  }
+}
+function validateRelation(doc, modelName, fieldName, relation, errors) {
+  const model = findModel(doc, modelName);
+  if (!model) return;
+  for (const f of relation.fields ?? []) {
+    if (!model.fields.some((mf) => mf.name === f)) {
+      errors.push(
+        `Relation '${modelName}.${fieldName}' references local field '${f}' which does not exist.`
+      );
+    }
+  }
+}
+function findDuplicates(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const dups = /* @__PURE__ */ new Set();
+  for (const v of values) {
+    if (seen.has(v)) dups.add(v);
+    seen.add(v);
+  }
+  return [...dups];
+}
+
+// src/schema/printer.ts
+function printSchema(doc) {
+  const blocks = [];
+  if (doc.datasource) {
+    const ds = doc.datasource;
+    const url = ds.url.kind === "env" ? `env("${ds.url.value}")` : `"${ds.url.value}"`;
+    blocks.push(
+      `datasource ${ds.name} {
+  provider = "${ds.provider}"
+  url      = ${url}
+}`
+    );
+  }
+  for (const gen of doc.generators) {
+    const lines = [`  provider = "${gen.provider}"`];
+    if (gen.output) lines.push(`  output   = "${gen.output}"`);
+    for (const [k, v] of Object.entries(gen.config)) {
+      if (k === "provider" || k === "output") continue;
+      lines.push(`  ${k} = "${v}"`);
+    }
+    blocks.push(`generator ${gen.name} {
+${lines.join("\n")}
+}`);
+  }
+  for (const enumNode of doc.enums) {
+    blocks.push(printEnum(enumNode));
+  }
+  for (const model of doc.models) {
+    blocks.push(printModel(model));
+  }
+  return blocks.join("\n\n") + "\n";
+}
+function printEnum(node) {
+  const lines = [];
+  if (node.documentation) lines.push(...docLines(node.documentation));
+  lines.push(`enum ${node.name} {`);
+  for (const v of node.values) {
+    lines.push(`  ${v.name}${v.dbName ? ` @map("${v.dbName}")` : ""}`);
+  }
+  if (node.dbName) lines.push(`
+  @@map("${node.dbName}")`);
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function printModel(model) {
+  const lines = [];
+  if (model.documentation) lines.push(...docLines(model.documentation));
+  lines.push(`model ${model.name} {`);
+  const nameWidth = Math.max(...model.fields.map((f) => f.name.length), 0);
+  const typeWidth = Math.max(...model.fields.map((f) => fieldType(f).length), 0);
+  for (const field of model.fields) {
+    if (field.documentation) {
+      lines.push(...docLines(field.documentation).map((l) => `  ${l}`));
+    }
+    const attrs = fieldAttributes(field);
+    const name = field.name.padEnd(nameWidth);
+    const type = fieldType(field).padEnd(typeWidth);
+    lines.push(`  ${name} ${type}${attrs ? ` ${attrs}` : ""}`.trimEnd());
+  }
+  const blockAttrs = modelBlockAttributes(model);
+  if (blockAttrs.length > 0) {
+    lines.push("");
+    for (const a of blockAttrs) lines.push(`  ${a}`);
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function fieldType(field) {
+  let t = field.type;
+  if (field.isList) t += "[]";
+  else if (!field.isRequired) t += "?";
+  return t;
+}
+function fieldAttributes(field) {
+  const parts = [];
+  if (field.isId) parts.push("@id");
+  if (field.isUnique) parts.push("@unique");
+  if (field.default) parts.push(`@default(${printDefault(field.default)})`);
+  if (field.isUpdatedAt) parts.push("@updatedAt");
+  if (field.relation) {
+    const rel = field.relation;
+    const args = [];
+    if (rel.name) args.push(`"${rel.name}"`);
+    if (rel.fields?.length) args.push(`fields: [${rel.fields.join(", ")}]`);
+    if (rel.references?.length)
+      args.push(`references: [${rel.references.join(", ")}]`);
+    if (rel.onDelete) args.push(`onDelete: ${rel.onDelete}`);
+    if (rel.onUpdate) args.push(`onUpdate: ${rel.onUpdate}`);
+    parts.push(args.length ? `@relation(${args.join(", ")})` : "@relation");
+  }
+  if (field.nativeType) {
+    const a = field.nativeType.args.length ? `(${field.nativeType.args.join(", ")})` : "";
+    parts.push(`@db.${field.nativeType.name}${a}`);
+  }
+  if (field.dbName) parts.push(`@map("${field.dbName}")`);
+  return parts.join(" ");
+}
+function printDefault(def) {
+  if (def.function) {
+    return `${def.function.name}(${def.function.args.map(printArgValue).join(", ")})`;
+  }
+  if (typeof def.literal === "string") {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(def.literal) ? def.literal : `"${def.literal}"`;
+  }
+  return String(def.literal);
+}
+function printArgValue(v) {
+  switch (v.kind) {
+    case "string":
+      return `"${v.value}"`;
+    case "number":
+      return String(v.value);
+    case "boolean":
+      return String(v.value);
+    case "ref":
+      return v.value;
+    case "array":
+      return `[${v.items.map(printArgValue).join(", ")}]`;
+    case "function":
+      return `${v.name}(${v.args.map(printArgValue).join(", ")})`;
+  }
+}
+function modelBlockAttributes(model) {
+  const out = [];
+  const inlineId = model.primaryKey.length === 1 && model.fields.find((f) => f.name === model.primaryKey[0])?.isId;
+  if (model.primaryKey.length > 0 && !inlineId) {
+    out.push(`@@id([${model.primaryKey.join(", ")}])`);
+  }
+  for (const u of model.uniqueIndexes) {
+    out.push(
+      `@@unique([${u.fields.join(", ")}]${u.name ? `, map: "${u.name}"` : ""})`
+    );
+  }
+  for (const i of model.indexes) {
+    out.push(
+      `@@index([${i.fields.join(", ")}]${i.name ? `, map: "${i.name}"` : ""})`
+    );
+  }
+  if (model.dbName) out.push(`@@map("${model.dbName}")`);
+  return out;
+}
+function docLines(documentation) {
+  return documentation.split("\n").map((l) => `/// ${l}`);
+}
+
+// src/utils/index.ts
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date) && !Buffer.isBuffer(v);
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function pascalCase(input) {
+  return input.toLowerCase().replace(
+    /[^a-zA-Z0-9]+(.)?/g,
+    (_, c) => c ? c.toUpperCase() : ""
+  ).replace(/^(.)/, (_, c) => c.toUpperCase());
+}
+function camelCase(input) {
+  const pascal = pascalCase(input);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function pluralize(word) {
+  if (/[^aeiou]y$/i.test(word)) return word.replace(/y$/i, "ies");
+  if (/(s|x|z|ch|sh)$/i.test(word)) return `${word}es`;
+  return `${word}s`;
+}
+function lowerFirst(input) {
+  return input.charAt(0).toLowerCase() + input.slice(1);
+}
+
+// src/schema/index.ts
+function parseSchema(source, file) {
+  return new Parser(source, file).parse();
+}
+function parseAndValidate(source, file) {
+  const doc = parseSchema(source, file);
+  validateSchema(doc);
+  return doc;
+}
+var DEFAULT_SCHEMA_PATHS = [
+  "ember/schema.ember",
+  "schema.ember",
+  "prisma/schema.ember"
+];
+function findSchemaPath(base = process.cwd(), explicit) {
+  if (explicit) {
+    const p = resolve(base, explicit);
+    return existsSync(p) ? p : void 0;
+  }
+  for (const candidate of DEFAULT_SCHEMA_PATHS) {
+    const p = resolve(base, candidate);
+    if (existsSync(p)) return p;
+  }
+  return void 0;
+}
+function loadSchema(path) {
+  const source = readFileSync(path, "utf8");
+  const document = parseAndValidate(source, path);
+  return {
+    document,
+    path,
+    databaseUrl: resolveDatasourceUrl(document, dirname(path))
+  };
+}
+function resolveDatasourceUrl(doc, _base) {
+  const ds = doc.datasource;
+  if (!ds) return void 0;
+  if (ds.url.kind === "literal") return ds.url.value;
+  return process.env[ds.url.value];
+}
+
+// src/driver/firebird-driver.ts
+import { AsyncLocalStorage } from "async_hooks";
+import Firebird from "node-firebird";
+var fb = Firebird;
+function isolationConstant(level) {
+  switch (level) {
+    case "READ_COMMITTED_READ_ONLY":
+      return fb.ISOLATION_READ_COMMITTED_READ_ONLY;
+    case "REPEATABLE_READ":
+      return fb.ISOLATION_REPEATABLE_READ;
+    case "SERIALIZABLE":
+      return fb.ISOLATION_SERIALIZABLE;
+    case "READ_COMMITTED":
+    default:
+      return fb.ISOLATION_READ_COMMITTED;
+  }
+}
+var FirebirdDriver = class {
+  pool = null;
+  options;
+  poolMax;
+  onQuery;
+  activeTx = new AsyncLocalStorage();
+  constructor(config, driverOptions) {
+    this.poolMax = config.poolMax ?? 5;
+    this.onQuery = driverOptions?.onQuery;
+    this.options = {
+      host: config.host,
+      port: config.port,
+      database: config.database,
+      user: config.user,
+      password: config.password,
+      role: config.role ?? "",
+      pageSize: config.pageSize ?? 4096,
+      encoding: config.encoding ?? "UTF8",
+      blobAsText: config.blobAsText ?? true,
+      lowercase_keys: config.lowercaseKeys ?? false,
+      retryConnectionInterval: 1e3,
+      // FB3+ secure auth (Srp) is negotiated by default; set explicitly to force
+      // a plugin, or "Legacy_Auth" for Firebird 2.1/2.5 servers.
+      ...config.authPlugin ? { pluginName: config.authPlugin } : {},
+      ...config.wireCompression != null ? { wireCompression: config.wireCompression } : {}
+    };
+  }
+  async connect() {
+    if (this.pool) return;
+    this.pool = fb.pool(this.poolMax, this.options);
+  }
+  async disconnect() {
+    if (!this.pool) return;
+    this.pool.destroy();
+    this.pool = null;
+  }
+  async transaction(fn, options) {
+    const existing = this.activeTx.getStore();
+    if (existing) {
+      return fn(existing);
+    }
+    await this.connect();
+    const db = await this.acquire();
+    const tr = await this.begin(db, options?.isolation);
+    const ctx = {
+      query: (sql, params) => this.runOnTransaction(tr, sql, params)
+    };
+    try {
+      const result = await this.activeTx.run(ctx, () => fn(ctx));
+      await this.commit(tr);
+      return result;
+    } catch (err) {
+      await this.safeRollback(tr);
+      throw err;
+    } finally {
+      db.detach();
+    }
+  }
+  // ---- promise wrappers over node-firebird -------------------------------
+  acquire() {
+    return new Promise((resolve3, reject) => {
+      this.pool.get((err, db) => {
+        if (err) return reject(wrap(err, "Failed to acquire connection"));
+        resolve3(db);
+      });
+    });
+  }
+  begin(db, isolation) {
+    return new Promise((resolve3, reject) => {
+      db.transaction(isolationConstant(isolation), (err, tr) => {
+        if (err) return reject(wrap(err, "Failed to start transaction"));
+        resolve3(tr);
+      });
+    });
+  }
+  runOnTransaction(tr, sql, params = []) {
+    const start = this.onQuery ? performance.now() : 0;
+    return new Promise((resolve3, reject) => {
+      tr.query(sql, [...params], (err, result) => {
+        if (err) return reject(wrap(err, "Query failed", sql));
+        const rows = normalizeRows(result);
+        if (this.onQuery) {
+          this.onQuery({
+            sql,
+            params,
+            durationMs: performance.now() - start,
+            rowCount: rows.length
+          });
+        }
+        resolve3(rows);
+      });
+    });
+  }
+  commit(tr) {
+    return new Promise((resolve3, reject) => {
+      tr.commit((err) => {
+        if (err) return reject(wrap(err, "Failed to commit transaction"));
+        resolve3();
+      });
+    });
+  }
+  safeRollback(tr) {
+    return new Promise((resolve3) => {
+      tr.rollback(() => resolve3());
+    });
+  }
+};
+function normalizeRows(result) {
+  if (Array.isArray(result)) return result;
+  if (result === void 0 || result === null) return [];
+  return [result];
+}
+function wrap(err, message, sql) {
+  const detail = err && typeof err === "object" && "message" in err ? String(err.message) : String(err);
+  return new DatabaseError(`${message}: ${detail}`, err, sql);
+}
+
+// src/driver/url.ts
+function parseConnectionUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new EmberError(`Invalid Firebird connection URL: ${url}`);
+  }
+  if (!/^firebird:?$/.test(parsed.protocol.replace(":", "") + ":")) {
+    if (parsed.protocol !== "firebird:") {
+      throw new EmberError(
+        `Unsupported protocol '${parsed.protocol}'. Expected 'firebird:'.`
+      );
+    }
+  }
+  const database = normalizeDatabasePath(parsed.pathname);
+  if (!database) {
+    throw new EmberError(`Connection URL is missing a database path: ${url}`);
+  }
+  const params = parsed.searchParams;
+  const config = {
+    host: parsed.hostname || "127.0.0.1",
+    port: parsed.port ? Number(parsed.port) : 3050,
+    database,
+    user: decodeURIComponent(parsed.username || "SYSDBA"),
+    password: decodeURIComponent(parsed.password || "masterkey"),
+    encoding: params.get("encoding") ?? "UTF8"
+  };
+  const role = params.get("role");
+  if (role) config.role = role;
+  const poolMax = params.get("poolMax") ?? params.get("connection_limit");
+  if (poolMax) config.poolMax = Number(poolMax);
+  const pageSize = params.get("pageSize");
+  if (pageSize) config.pageSize = Number(pageSize);
+  const auth = (params.get("authPlugin") ?? params.get("auth"))?.toLowerCase();
+  if (auth === "legacy" || auth === "legacy_auth") config.authPlugin = "Legacy_Auth";
+  else if (auth === "srp") config.authPlugin = "Srp";
+  const wireCompression = params.get("wireCompression");
+  if (wireCompression != null) {
+    config.wireCompression = wireCompression !== "false" && wireCompression !== "0";
+  }
+  const version = params.get("version");
+  if (version) config.version = normalizeVersion(version);
+  return config;
+}
+var VERSIONS = /* @__PURE__ */ new Set(["2.1", "2.5", "3", "4", "5"]);
+function normalizeVersion(raw) {
+  const trimmed = raw.trim();
+  if (VERSIONS.has(trimmed)) return trimmed;
+  if (/^2\.1/.test(trimmed)) return "2.1";
+  if (/^2\.5/.test(trimmed)) return "2.5";
+  const major = trimmed.split(".")[0];
+  if (major && VERSIONS.has(major)) return major;
+  return void 0;
+}
+function normalizeDatabasePath(pathname) {
+  let p = decodeURIComponent(pathname);
+  if (p.startsWith("//")) p = p.slice(1);
+  if (/^\/[A-Za-z]:\//.test(p)) p = p.slice(1);
+  return p;
+}
+function buildConnectionUrl(config) {
+  const auth = `${encodeURIComponent(config.user)}:${encodeURIComponent(
+    config.password
+  )}`;
+  const dbPath = config.database.startsWith("/") ? `/${config.database}` : `/${config.database}`;
+  const url = new URL(`firebird://${auth}@${config.host}:${config.port}${dbPath}`);
+  if (config.role) url.searchParams.set("role", config.role);
+  return url.toString();
+}
+
+// src/driver/index.ts
+function createDriver(source, options) {
+  const config = typeof source === "string" ? parseConnectionUrl(source) : source;
+  return new FirebirdDriver(config, options);
+}
+
+// src/sql/fragment.ts
+var Sql = class _Sql {
+  parts = [];
+  params = [];
+  static raw(text) {
+    return new _Sql().push(text);
+  }
+  static value(value) {
+    return new _Sql().bind(value);
+  }
+  static join(fragments, separator) {
+    const out = new _Sql();
+    fragments.forEach((frag, i) => {
+      if (i > 0) out.push(separator);
+      out.append(frag);
+    });
+    return out;
+  }
+  /** Append raw, trusted SQL text (keywords, already-escaped identifiers). */
+  push(text) {
+    this.parts.push(text);
+    return this;
+  }
+  /** Append a `?` placeholder bound to `value`. */
+  bind(value) {
+    this.parts.push("?");
+    this.params.push(value);
+    return this;
+  }
+  /** Append a comma-separated list of placeholders bound to `values`. */
+  bindList(values) {
+    this.parts.push(values.map(() => "?").join(", "));
+    this.params.push(...values);
+    return this;
+  }
+  /** Merge another fragment (text + params) into this one. */
+  append(other) {
+    this.parts.push(other.text);
+    this.params.push(...other.params);
+    return this;
+  }
+  get text() {
+    return this.parts.join("");
+  }
+  isEmpty() {
+    return this.text.trim().length === 0;
+  }
+  toQuery() {
+    return { sql: this.text, params: this.params };
+  }
+};
+
+// src/sql/dialect.ts
+var FirebirdDialect = class {
+  supportsReturning = true;
+  version;
+  supportsBooleanType;
+  supportsIdentity;
+  supportsWindowFunctions;
+  constructor(options = {}) {
+    this.version = options.version ?? "3";
+    const rank = versionRank(this.version);
+    this.supportsBooleanType = rank >= 30;
+    this.supportsIdentity = rank >= 30;
+    this.supportsWindowFunctions = rank >= 30;
+  }
+  booleanColumnType() {
+    return this.supportsBooleanType ? "BOOLEAN" : "SMALLINT";
+  }
+  quoteId(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+  }
+  quoteRef(table, column) {
+    return `${this.quoteId(table)}.${this.quoteId(column)}`;
+  }
+  paginationClause(take, skip) {
+    const parts = [];
+    if (typeof take === "number" && take >= 0) {
+      parts.push(`FIRST ${Math.trunc(take)}`);
+    }
+    if (typeof skip === "number" && skip > 0) {
+      parts.push(`SKIP ${Math.trunc(skip)}`);
+    }
+    return parts.join(" ");
+  }
+  caseInsensitive(expr) {
+    return `UPPER(${expr})`;
+  }
+  defaultFunctionSql(name) {
+    switch (name) {
+      case "now":
+        return "CURRENT_TIMESTAMP";
+      case "uuid":
+      case "cuid":
+        return "UUID_TO_CHAR(GEN_UUID())";
+      case "autoincrement":
+        return null;
+      // handled via generators/identity, not an inline default
+      default:
+        return null;
+    }
+  }
+  coerceValue(value) {
+    if (value === null || value === void 0) return null;
+    if (value instanceof Date) return value;
+    if (Buffer.isBuffer(value)) return value;
+    if (typeof value === "boolean") {
+      return this.supportsBooleanType ? value : value ? 1 : 0;
+    }
+    if (typeof value === "bigint") return value;
+    if (typeof value === "number") return value;
+    if (typeof value === "string") return value;
+    return JSON.stringify(value);
+  }
+};
+function versionRank(version) {
+  switch (version) {
+    case "2.1":
+      return 21;
+    case "2.5":
+      return 25;
+    case "3":
+      return 30;
+    case "4":
+      return 40;
+    case "5":
+      return 50;
+    default:
+      return 30;
+  }
+}
+
+// src/query/order.ts
+function compileOrderBy(model, tableAlias, orderBy, dialect) {
+  if (!orderBy) return new Sql();
+  const entries = normalize(orderBy);
+  if (entries.length === 0) return new Sql();
+  const parts = entries.map(([fieldName, dir]) => {
+    const field = model.fields.find((f) => f.name === fieldName);
+    if (!field || field.kind === "object") {
+      throw new QueryValidationError(
+        `Cannot order '${model.name}' by '${fieldName}'.`
+      );
+    }
+    const ref = dialect.quoteRef(tableAlias, fieldColumn(field));
+    return Sql.raw(`${ref} ${dir === "desc" ? "DESC" : "ASC"}`);
+  });
+  return Sql.join(parts, ", ");
+}
+function normalize(orderBy) {
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  const out = [];
+  for (const obj of list) {
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === "asc" || value === "desc") out.push([key, value]);
+    }
+  }
+  return out;
+}
+
+// src/query/relations.ts
+function resolveRelation(schema, model, field) {
+  if (field.kind !== "object") {
+    throw new QueryValidationError(
+      `Field '${model.name}.${field.name}' is not a relation.`
+    );
+  }
+  const relatedModel = findModel(schema, field.type);
+  if (!relatedModel) {
+    throw new QueryValidationError(
+      `Relation '${model.name}.${field.name}' points to unknown model '${field.type}'.`
+    );
+  }
+  if (field.relation?.fields?.length) {
+    const fromFields2 = field.relation.fields;
+    const toFields2 = field.relation.references ?? idFields(relatedModel).map((f) => f.name);
+    return build(field, model, relatedModel, fromFields2, toFields2, true);
+  }
+  const partner = findPartnerField(schema, model, field, relatedModel);
+  if (partner?.relation?.fields?.length) {
+    const toFields2 = partner.relation.fields;
+    const fromFields2 = partner.relation.references ?? idFields(model).map((f) => f.name);
+    return build(field, model, relatedModel, fromFields2, toFields2, false);
+  }
+  const fromFields = idFields(model).map((f) => f.name);
+  const toFields = idFields(relatedModel).map((f) => f.name);
+  return build(field, model, relatedModel, fromFields, toFields, false);
+}
+function build(field, model, relatedModel, fromFields, toFields, owns) {
+  return {
+    field,
+    relatedModel,
+    fromFields,
+    toFields,
+    fromColumns: fromFields.map((n) => columnOf(model, n)),
+    toColumns: toFields.map((n) => columnOf(relatedModel, n)),
+    isList: field.isList,
+    owns
+  };
+}
+function columnOf(model, fieldName) {
+  const f = model.fields.find((x) => x.name === fieldName);
+  if (!f) {
+    throw new QueryValidationError(
+      `Field '${fieldName}' not found on model '${model.name}'.`
+    );
+  }
+  return fieldColumn(f);
+}
+function findPartnerField(_schema, model, field, relatedModel) {
+  const candidates = relatedModel.fields.filter(
+    (f) => f.kind === "object" && f.type === model.name
+  );
+  if (field.relation?.name) {
+    const byName = candidates.find(
+      (f) => f.relation?.name === field.relation?.name
+    );
+    if (byName) return byName;
+  }
+  const owning = candidates.find((f) => f.relation?.fields?.length);
+  return owning ?? candidates[0];
+}
+
+// src/query/where.ts
+var SCALAR_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "not",
+  "in",
+  "notIn",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "contains",
+  "startsWith",
+  "endsWith",
+  "mode"
+]);
+function compileWhere(model, tableAlias, where, ctx) {
+  if (!where || Object.keys(where).length === 0) return new Sql();
+  const conditions = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (value === void 0) continue;
+    if (key === "AND") {
+      conditions.push(combineList(asArray(value), model, tableAlias, ctx, "AND"));
+      continue;
+    }
+    if (key === "OR") {
+      conditions.push(combineList(asArray(value), model, tableAlias, ctx, "OR"));
+      continue;
+    }
+    if (key === "NOT") {
+      const inner = combineList(asArray(value), model, tableAlias, ctx, "AND");
+      if (!inner.isEmpty()) {
+        conditions.push(new Sql().push("NOT (").append(inner).push(")"));
+      }
+      continue;
+    }
+    const field = model.fields.find((f) => f.name === key);
+    if (!field) {
+      throw new QueryValidationError(
+        `Unknown field '${key}' in where clause of model '${model.name}'.`
+      );
+    }
+    if (field.kind === "object") {
+      conditions.push(
+        compileRelationFilter(model, tableAlias, field, value, ctx)
+      );
+    } else {
+      conditions.push(compileScalar(tableAlias, field, value, ctx));
+    }
+  }
+  const nonEmpty = conditions.filter((c) => !c.isEmpty());
+  if (nonEmpty.length === 0) return new Sql();
+  return wrapAnd(nonEmpty);
+}
+function combineList(list, model, tableAlias, ctx, op) {
+  const parts = list.map((w) => compileWhere(model, tableAlias, w, ctx)).filter((p) => !p.isEmpty());
+  if (parts.length === 0) return new Sql();
+  if (parts.length === 1) return parts[0];
+  const joined = Sql.join(
+    parts.map((p) => new Sql().push("(").append(p).push(")")),
+    ` ${op} `
+  );
+  return new Sql().push("(").append(joined).push(")");
+}
+function wrapAnd(parts) {
+  if (parts.length === 1) return parts[0];
+  const joined = Sql.join(
+    parts.map((p) => new Sql().push("(").append(p).push(")")),
+    " AND "
+  );
+  return new Sql().push("(").append(joined).push(")");
+}
+function compileScalar(tableAlias, field, value, ctx) {
+  const ref = ctx.dialect.quoteRef(tableAlias, fieldColumn(field));
+  if (field.type === "Json" && isJsonFilterObject(value)) {
+    return compileJsonFilter(ref, field, value, ctx);
+  }
+  if (!isFilterObject(value)) {
+    if (value === null) return Sql.raw(`${ref} IS NULL`);
+    return new Sql().push(`${ref} = `).bind(ctx.dialect.coerceValue(value));
+  }
+  const filter = value;
+  const insensitive = filter.mode === "insensitive";
+  const parts = [];
+  for (const [op, opValue] of Object.entries(filter)) {
+    if (op === "mode") continue;
+    if (opValue === void 0) continue;
+    parts.push(compileOperator(ref, op, opValue, insensitive, ctx));
+  }
+  if (parts.length === 0) return new Sql();
+  return wrapAnd(parts);
+}
+var JSON_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "not",
+  "string_contains",
+  "string_starts_with",
+  "string_ends_with",
+  "path"
+]);
+function isJsonFilterObject(value) {
+  return isPlainObject(value) && Object.keys(value).some((k) => JSON_OPERATORS.has(k));
+}
+function compileJsonFilter(ref, field, filter, ctx) {
+  const parts = [];
+  for (const [op, raw] of Object.entries(filter)) {
+    if (raw === void 0) continue;
+    switch (op) {
+      case "path":
+        throw new QueryValidationError(
+          `JSON 'path' filtering is not supported on Firebird (no JSON SQL functions). Filter '${field.name}' in application code or with a generated column.`
+        );
+      case "equals":
+        parts.push(
+          raw === null ? Sql.raw(`${ref} IS NULL`) : new Sql().push(`${ref} = `).bind(jsonText(raw))
+        );
+        break;
+      case "not":
+        parts.push(
+          raw === null ? Sql.raw(`${ref} IS NOT NULL`) : new Sql().push(`${ref} <> `).bind(jsonText(raw))
+        );
+        break;
+      case "string_contains":
+        parts.push(jsonLike(ref, `%${escapeLike(String(raw))}%`));
+        break;
+      case "string_starts_with":
+        parts.push(jsonLike(ref, `${escapeLike(String(raw))}%`));
+        break;
+      case "string_ends_with":
+        parts.push(jsonLike(ref, `%${escapeLike(String(raw))}`));
+        break;
+      default:
+        throw new QueryValidationError(`Unsupported JSON filter operator '${op}'.`);
+    }
+  }
+  return parts.length ? wrapAnd(parts) : new Sql();
+}
+function jsonText(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function jsonLike(ref, pattern) {
+  return new Sql().push(`${ref} LIKE `).bind(pattern).push(" ESCAPE '\\'");
+}
+function compileOperator(ref, op, value, insensitive, ctx) {
+  const d = ctx.dialect;
+  const bound = (v) => d.coerceValue(v);
+  const lhs = insensitive ? d.caseInsensitive(ref) : ref;
+  const rhs = (v) => insensitive && typeof v === "string" ? new Sql().push("UPPER(").bind(bound(v)).push(")") : Sql.value(bound(v));
+  switch (op) {
+    case "equals":
+      if (value === null) return Sql.raw(`${ref} IS NULL`);
+      return new Sql().push(`${lhs} = `).append(rhs(value));
+    case "not":
+      if (value === null) return Sql.raw(`${ref} IS NOT NULL`);
+      if (isFilterObject(value)) {
+        const inner = compileScalarFromRef(ref, value, insensitive, ctx);
+        return new Sql().push("NOT (").append(inner).push(")");
+      }
+      return new Sql().push(`${lhs} <> `).append(rhs(value));
+    case "in":
+      return inClause(lhs, asUnknownArray(value), insensitive, ctx, false);
+    case "notIn":
+      return inClause(lhs, asUnknownArray(value), insensitive, ctx, true);
+    case "lt":
+      return new Sql().push(`${lhs} < `).append(rhs(value));
+    case "lte":
+      return new Sql().push(`${lhs} <= `).append(rhs(value));
+    case "gt":
+      return new Sql().push(`${lhs} > `).append(rhs(value));
+    case "gte":
+      return new Sql().push(`${lhs} >= `).append(rhs(value));
+    case "contains":
+      return likeClause(lhs, `%${escapeLike(String(value))}%`, insensitive);
+    case "startsWith":
+      return likeClause(lhs, `${escapeLike(String(value))}%`, insensitive);
+    case "endsWith":
+      return likeClause(lhs, `%${escapeLike(String(value))}`, insensitive);
+    default:
+      throw new QueryValidationError(`Unsupported filter operator '${op}'.`);
+  }
+}
+function compileScalarFromRef(ref, filter, insensitive, ctx) {
+  const parts = [];
+  for (const [op, opValue] of Object.entries(filter)) {
+    if (op === "mode" || opValue === void 0) continue;
+    parts.push(compileOperator(ref, op, opValue, insensitive, ctx));
+  }
+  return parts.length ? wrapAnd(parts) : new Sql();
+}
+function inClause(lhs, values, insensitive, ctx, negate) {
+  if (values.length === 0) {
+    return Sql.raw(negate ? "1 = 1" : "1 = 0");
+  }
+  const coerced = values.map(
+    (v) => insensitive && typeof v === "string" ? String(v).toUpperCase() : ctx.dialect.coerceValue(v)
+  );
+  const sql = new Sql().push(`${lhs} ${negate ? "NOT IN" : "IN"} (`);
+  sql.bindList(coerced);
+  sql.push(")");
+  return sql;
+}
+function likeClause(lhs, pattern, insensitive) {
+  const value = insensitive ? pattern.toUpperCase() : pattern;
+  return new Sql().push(`${lhs} LIKE `).bind(value).push(" ESCAPE '\\'");
+}
+function compileRelationFilter(model, tableAlias, field, value, ctx) {
+  const rel = resolveRelation(ctx.schema, model, field);
+  const filter = isPlainObject(value) ? value : {};
+  const hasOperator = "some" in filter || "every" in filter || "none" in filter || "is" in filter || "isNot" in filter;
+  if (!rel.isList && !hasOperator) {
+    return existsClause(model, tableAlias, rel, value, ctx, false);
+  }
+  const parts = [];
+  if (filter.some !== void 0) {
+    parts.push(existsClause(model, tableAlias, rel, filter.some ?? {}, ctx, false));
+  }
+  if (filter.none !== void 0) {
+    parts.push(existsClause(model, tableAlias, rel, filter.none ?? {}, ctx, true));
+  }
+  if (filter.every !== void 0) {
+    parts.push(
+      existsClause(model, tableAlias, rel, filter.every ?? {}, ctx, true, true)
+    );
+  }
+  if (filter.is !== void 0) {
+    if (filter.is === null) {
+      parts.push(notExists(model, tableAlias, rel, {}, ctx));
+    } else {
+      parts.push(existsClause(model, tableAlias, rel, filter.is, ctx, false));
+    }
+  }
+  if (filter.isNot !== void 0) {
+    if (filter.isNot === null) {
+      parts.push(existsClause(model, tableAlias, rel, {}, ctx, false));
+    } else {
+      parts.push(existsClause(model, tableAlias, rel, filter.isNot, ctx, true));
+    }
+  }
+  return parts.length ? wrapAnd(parts) : new Sql();
+}
+function notExists(model, tableAlias, rel, sub, ctx) {
+  return existsClause(model, tableAlias, rel, sub, ctx, true);
+}
+function existsClause(_model, tableAlias, rel, sub, ctx, negate, everyMode = false) {
+  const childAlias = `r${ctx.alias.next++}`;
+  const childTable = ctx.dialect.quoteId(modelTable(rel.relatedModel));
+  const sql = new Sql();
+  sql.push(`${negate ? "NOT EXISTS" : "EXISTS"} (SELECT 1 FROM ${childTable} ${ctx.dialect.quoteId(childAlias)} WHERE `);
+  const joins = rel.fromColumns.map((fromCol, i) => {
+    const toCol = rel.toColumns[i];
+    return `${ctx.dialect.quoteRef(childAlias, toCol)} = ${ctx.dialect.quoteRef(tableAlias, fromCol)}`;
+  });
+  sql.push(joins.join(" AND "));
+  const subSql = compileWhere(rel.relatedModel, childAlias, sub, ctx);
+  if (!subSql.isEmpty()) {
+    if (everyMode) {
+      sql.push(" AND NOT (").append(subSql).push(")");
+    } else {
+      sql.push(" AND ").append(subSql);
+    }
+  }
+  sql.push(")");
+  return sql;
+}
+function isFilterObject(value) {
+  if (!isPlainObject(value)) return false;
+  return Object.keys(value).some((k) => SCALAR_OPERATORS.has(k));
+}
+function asArray(value) {
+  const list = Array.isArray(value) ? value : [value];
+  return list.filter(
+    (v) => v !== null && typeof v === "object"
+  );
+}
+function asUnknownArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function escapeLike(input) {
+  return input.replace(/[\\%_]/g, (c) => `\\${c}`);
+}
+
+// src/query/having.ts
+var AGG_FN = {
+  _count: "COUNT",
+  _sum: "SUM",
+  _avg: "AVG",
+  _min: "MIN",
+  _max: "MAX"
+};
+var COMPARATORS = {
+  equals: "=",
+  not: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+function compileHaving(model, alias, having, ctx) {
+  if (!having || Object.keys(having).length === 0) return new Sql();
+  const parts = [];
+  for (const [key, value] of Object.entries(having)) {
+    if (value === void 0) continue;
+    if (key === "AND" || key === "OR") {
+      const list = Array.isArray(value) ? value : [value];
+      const compiled = list.map((w) => compileHaving(model, alias, w, ctx)).filter((s) => !s.isEmpty());
+      if (compiled.length) parts.push(joinBool(compiled, key));
+      continue;
+    }
+    if (key === "NOT") {
+      const inner = compileHaving(model, alias, value, ctx);
+      if (!inner.isEmpty()) parts.push(new Sql().push("NOT (").append(inner).push(")"));
+      continue;
+    }
+    if (key in AGG_FN) {
+      parts.push(...aggregateConditions(model, alias, key, value, ctx));
+      continue;
+    }
+    const field = model.fields.find((f) => f.name === key && f.kind !== "object");
+    if (!field) {
+      throw new QueryValidationError(
+        `Unknown having field '${model.name}.${key}'.`
+      );
+    }
+    if (isAggregateWrapper(value)) {
+      const ref = ctx.dialect.quoteRef(alias, fieldColumn(field));
+      for (const [agg, filter] of Object.entries(value)) {
+        if (!(agg in AGG_FN)) continue;
+        parts.push(comparison(`${AGG_FN[agg]}(${ref})`, filter, ctx.dialect));
+      }
+    } else {
+      const cond = compileWhere(model, alias, { [key]: value }, ctx);
+      if (!cond.isEmpty()) parts.push(cond);
+    }
+  }
+  const nonEmpty = parts.filter((p) => !p.isEmpty());
+  if (nonEmpty.length === 0) return new Sql();
+  return joinBool(nonEmpty, "AND");
+}
+function aggregateConditions(model, alias, agg, spec, ctx) {
+  if (!isPlainObject(spec)) return [];
+  const out = [];
+  for (const [fieldName, filter] of Object.entries(spec)) {
+    const field = model.fields.find((f) => f.name === fieldName && f.kind !== "object");
+    if (!field) continue;
+    const ref = ctx.dialect.quoteRef(alias, fieldColumn(field));
+    out.push(comparison(`${AGG_FN[agg]}(${ref})`, filter, ctx.dialect));
+  }
+  return out;
+}
+function comparison(lhs, filter, dialect) {
+  if (!isPlainObject(filter)) {
+    return new Sql().push(`${lhs} = `).bind(dialect.coerceValue(filter));
+  }
+  const parts = [];
+  for (const [op, v] of Object.entries(filter)) {
+    const sqlOp = COMPARATORS[op];
+    if (!sqlOp) {
+      throw new QueryValidationError(`Unsupported having operator '${op}'.`);
+    }
+    parts.push(new Sql().push(`${lhs} ${sqlOp} `).bind(dialect.coerceValue(v)));
+  }
+  return parts.length === 1 ? parts[0] : joinBool(parts, "AND");
+}
+function isAggregateWrapper(value) {
+  return isPlainObject(value) && Object.keys(value).some((k) => k in AGG_FN);
+}
+function joinBool(parts, op) {
+  if (parts.length === 1) return parts[0];
+  const joined = Sql.join(
+    parts.map((p) => new Sql().push("(").append(p).push(")")),
+    ` ${op} `
+  );
+  return new Sql().push("(").append(joined).push(")");
+}
+
+// src/query/compiler.ts
+function setAssignments(values) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [col, value] of values) out.set(col, { kind: "set", value });
+  return out;
+}
+var ROOT_ALIAS = "t0";
+function newContext(schema, dialect) {
+  return { schema, dialect, alias: { next: 1 } };
+}
+function compileFindMany(model, options, projection, ctx) {
+  const d = ctx.dialect;
+  const cols = projection.map(
+    (f) => `${d.quoteRef(ROOT_ALIAS, fieldColumn(f))} AS ${d.quoteId(f.name)}`
+  );
+  const sql = new Sql();
+  const pagination = d.paginationClause(options.take, options.skip);
+  sql.push(pagination ? `SELECT ${pagination} ` : "SELECT ");
+  sql.push(cols.join(", "));
+  sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(sql, model, options.where, ctx);
+  const order = compileOrderBy(model, ROOT_ALIAS, options.orderBy, d);
+  if (!order.isEmpty()) sql.push(" ORDER BY ").append(order);
+  return { sql, columns: projection };
+}
+function compileDistinctFindMany(model, options, projection, distinctFields, ctx) {
+  const d = ctx.dialect;
+  const innerOrder = options.orderBy ? compileOrderBy(model, ROOT_ALIAS, options.orderBy, d) : defaultOrder(model, d);
+  const partitionBy = distinctFields.map((f) => d.quoteRef(ROOT_ALIAS, fieldColumn(f))).join(", ");
+  const inner = new Sql();
+  const innerCols = projection.map(
+    (f) => `${d.quoteRef(ROOT_ALIAS, fieldColumn(f))} AS ${d.quoteId(f.name)}`
+  );
+  inner.push(`SELECT ${innerCols.join(", ")}, ROW_NUMBER() OVER (PARTITION BY ${partitionBy} ORDER BY `);
+  inner.append(innerOrder);
+  inner.push(`) AS ${d.quoteId("__rn")}`);
+  inner.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(inner, model, options.where, ctx);
+  const sql = new Sql();
+  const pagination = d.paginationClause(options.take, options.skip);
+  const sub = "sub";
+  const outerCols = projection.map((f) => `${d.quoteRef(sub, f.name)} AS ${d.quoteId(f.name)}`).join(", ");
+  sql.push(pagination ? `SELECT ${pagination} ` : "SELECT ");
+  sql.push(outerCols);
+  sql.push(` FROM (`).append(inner).push(`) ${d.quoteId(sub)}`);
+  sql.push(` WHERE ${d.quoteRef(sub, "__rn")} = 1`);
+  const outerOrder = outerOrderBy(model, sub, options.orderBy, d);
+  if (!outerOrder.isEmpty()) sql.push(" ORDER BY ").append(outerOrder);
+  return { sql, columns: projection };
+}
+function compileCount(model, where, ctx, pagination) {
+  const d = ctx.dialect;
+  const sql = new Sql();
+  const clause = pagination ? d.paginationClause(pagination.take, pagination.skip) : "";
+  sql.push(clause ? `SELECT ${clause} COUNT(*) AS "_count"` : `SELECT COUNT(*) AS "_count"`);
+  sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(sql, model, where, ctx);
+  return sql;
+}
+function compileAggregate(model, args, ctx) {
+  const d = ctx.dialect;
+  const selects = aggregateSelections(model, args, d);
+  if (selects.length === 0) {
+    throw new QueryValidationError("Aggregate requires at least one operator.");
+  }
+  const sql = new Sql();
+  sql.push(`SELECT ${selects.join(", ")}`);
+  sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(sql, model, args.where, ctx);
+  return sql;
+}
+function compileGroupBy(model, args, ctx) {
+  const d = ctx.dialect;
+  const groupColumns = args.by.map((name) => requireScalar(model, name));
+  const groupSelects = groupColumns.map(
+    (f) => `${d.quoteRef(ROOT_ALIAS, fieldColumn(f))} AS ${d.quoteId(f.name)}`
+  );
+  const aggSelects = aggregateSelections(model, args, d);
+  const sql = new Sql();
+  sql.push(`SELECT ${[...groupSelects, ...aggSelects].join(", ")}`);
+  sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`);
+  appendWhere(sql, model, args.where, ctx);
+  sql.push(
+    ` GROUP BY ${groupColumns.map((f) => d.quoteRef(ROOT_ALIAS, fieldColumn(f))).join(", ")}`
+  );
+  const having = compileHaving(model, ROOT_ALIAS, args.having, ctx);
+  if (!having.isEmpty()) sql.push(" HAVING ").append(having);
+  const order = compileOrderBy(model, ROOT_ALIAS, args.orderBy, d);
+  if (!order.isEmpty()) sql.push(" ORDER BY ").append(order);
+  return { sql, groupColumns };
+}
+function compileInsert(model, row, ctx, returning) {
+  const d = ctx.dialect;
+  const sql = new Sql();
+  const columns = [...row.keys()];
+  sql.push(`INSERT INTO ${d.quoteId(modelTable(model))} (`);
+  sql.push(columns.map((c) => d.quoteId(c)).join(", "));
+  sql.push(") VALUES (");
+  sql.bindList(columns.map((c) => row.get(c)));
+  sql.push(")");
+  appendReturning(sql, d, returning);
+  return { sql, columns: returning };
+}
+function compileUpdate(model, where, assignments, ctx, returning) {
+  const d = ctx.dialect;
+  if (assignments.size === 0) {
+    throw new QueryValidationError("Update requires at least one field to set.");
+  }
+  const sql = new Sql();
+  sql.push(`UPDATE ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)} SET `);
+  const cols = [...assignments.keys()];
+  cols.forEach((col, i) => {
+    if (i > 0) sql.push(", ");
+    const assignment = assignments.get(col);
+    const quoted = d.quoteId(col);
+    if (assignment.kind === "arith") {
+      sql.push(`${quoted} = ${quoted} ${assignment.op} `).bind(assignment.value);
+    } else {
+      sql.push(`${quoted} = `).bind(assignment.value);
+    }
+  });
+  appendWhere(sql, model, where, ctx);
+  if (returning) appendReturning(sql, d, returning);
+  return { sql, columns: returning ?? [] };
+}
+function compileDelete(model, where, ctx, returning) {
+  const d = ctx.dialect;
+  const sql = new Sql();
+  sql.push(
+    `DELETE FROM ${d.quoteId(modelTable(model))} ${d.quoteId(ROOT_ALIAS)}`
+  );
+  appendWhere(sql, model, where, ctx);
+  if (returning) appendReturning(sql, d, returning);
+  return { sql, columns: returning ?? [] };
+}
+function appendWhere(sql, model, where, ctx) {
+  const compiled = compileWhere(model, ROOT_ALIAS, where, ctx);
+  if (!compiled.isEmpty()) sql.push(" WHERE ").append(compiled);
+}
+function defaultOrder(model, d) {
+  const ids = idFields(model);
+  const cols = (ids.length ? ids : model.fields.filter((f) => f.kind !== "object")).map((f) => `${d.quoteRef(ROOT_ALIAS, fieldColumn(f))} ASC`);
+  return Sql.raw(cols.join(", "));
+}
+function outerOrderBy(model, alias, orderBy, d) {
+  if (!orderBy) return new Sql();
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  const parts = [];
+  for (const obj of list) {
+    for (const [name, dir] of Object.entries(obj)) {
+      if (dir !== "asc" && dir !== "desc") continue;
+      if (!model.fields.some((f) => f.name === name && f.kind !== "object")) {
+        continue;
+      }
+      parts.push(
+        Sql.raw(`${d.quoteRef(alias, name)} ${dir === "desc" ? "DESC" : "ASC"}`)
+      );
+    }
+  }
+  return Sql.join(parts, ", ");
+}
+function appendReturning(sql, d, returning) {
+  if (returning.length === 0) return;
+  sql.push(" RETURNING ");
+  sql.push(
+    returning.map((f) => `${d.quoteId(fieldColumn(f))} AS ${d.quoteId(f.name)}`).join(", ")
+  );
+}
+function aggregateSelections(model, args, d) {
+  const out = [];
+  if (args._count) {
+    if (args._count === true) {
+      out.push(`COUNT(*) AS "_count_all"`);
+    } else {
+      for (const field of trueKeys(args._count)) {
+        const col = d.quoteRef(ROOT_ALIAS, fieldColumn(requireScalar(model, field)));
+        out.push(`COUNT(${col}) AS ${d.quoteId(`_count_${field}`)}`);
+      }
+    }
+  }
+  pushAgg(out, "SUM", "_sum", model, args._sum, d);
+  pushAgg(out, "AVG", "_avg", model, args._avg, d);
+  pushAgg(out, "MIN", "_min", model, args._min, d);
+  pushAgg(out, "MAX", "_max", model, args._max, d);
+  return out;
+}
+function pushAgg(out, fn, prefix, model, spec, d) {
+  if (!spec) return;
+  for (const field of trueKeys(spec)) {
+    const col = d.quoteRef(ROOT_ALIAS, fieldColumn(requireScalar(model, field)));
+    out.push(`${fn}(${col}) AS ${d.quoteId(`${prefix}_${field}`)}`);
+  }
+}
+function trueKeys(spec) {
+  return Object.entries(spec).filter(([, v]) => v === true).map(([k]) => k);
+}
+function requireScalar(model, name) {
+  const field = model.fields.find((f) => f.name === name);
+  if (!field || field.kind === "object") {
+    throw new QueryValidationError(
+      `'${name}' is not a scalar field on model '${model.name}'.`
+    );
+  }
+  return field;
+}
+
+// src/query/coerce.ts
+function coerceFromDb(value, field) {
+  if (value === null || value === void 0) return null;
+  switch (field.type) {
+    case "Boolean":
+      return toBoolean(value);
+    case "Int":
+      return typeof value === "number" ? value : Number(value);
+    case "BigInt":
+      return typeof value === "bigint" ? value : BigInt(String(value));
+    case "Float":
+    case "Decimal":
+      return typeof value === "number" ? value : Number(value);
+    case "DateTime":
+      return value instanceof Date ? value : new Date(String(value));
+    case "Json":
+      return parseJson(value);
+    case "Bytes":
+      return Buffer.isBuffer(value) ? value : Buffer.from(String(value));
+    case "String":
+    default:
+      return typeof value === "string" ? value : String(value);
+  }
+}
+function coerceRow(row, fields) {
+  const out = {};
+  for (const field of fields) {
+    if (field.name in row) {
+      out[field.name] = coerceFromDb(row[field.name], field);
+    }
+  }
+  return out;
+}
+function toBoolean(value) {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  const s = String(value).trim().toUpperCase();
+  return s === "1" || s === "T" || s === "TRUE" || s === "Y";
+}
+function parseJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// src/query/defaults.ts
+import { randomUUID } from "crypto";
+function applyCreateDefaults(model, data) {
+  const out = { ...data };
+  for (const field of model.fields) {
+    if (field.kind === "object") continue;
+    if (field.isUpdatedAt && out[field.name] === void 0) {
+      out[field.name] = /* @__PURE__ */ new Date();
+      continue;
+    }
+    if (out[field.name] !== void 0) continue;
+    const def = field.default;
+    if (!def) continue;
+    if (def.function) {
+      const computed = computeFunctionDefault(def.function.name);
+      if (computed !== SKIP) out[field.name] = computed;
+      continue;
+    }
+    if (def.literal !== void 0) {
+      out[field.name] = def.literal;
+    }
+  }
+  return out;
+}
+function applyUpdateDefaults(model, data) {
+  const out = { ...data };
+  for (const field of model.fields) {
+    if (field.isUpdatedAt && out[field.name] === void 0) {
+      out[field.name] = /* @__PURE__ */ new Date();
+    }
+  }
+  return out;
+}
+var SKIP = /* @__PURE__ */ Symbol("skip-default");
+function computeFunctionDefault(name) {
+  switch (name) {
+    case "now":
+      return /* @__PURE__ */ new Date();
+    case "uuid":
+      return randomUUID();
+    case "cuid":
+      return generateCuid();
+    case "autoincrement":
+      return SKIP;
+    default:
+      return SKIP;
+  }
+}
+function generateCuid() {
+  const time = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `c${time}${rand}`;
+}
+function isAutoincrement(field) {
+  return field.default?.function?.name === "autoincrement";
+}
+
+// src/query/writer.ts
+var WriteProcessor = class {
+  constructor(schema, dialect, exec) {
+    this.schema = schema;
+    this.dialect = dialect;
+    this.exec = exec;
+  }
+  schema;
+  dialect;
+  exec;
+  ctx() {
+    return newContext(this.schema, this.dialect);
+  }
+  /** Insert one row (with nested writes) and return its key values. */
+  async create(model, data) {
+    const { scalars, owning, children } = this.partition(model, data);
+    for (const [field, op] of owning) {
+      for (const [fieldName, value] of await this.resolveOwning(model, field, op)) {
+        scalars.set(fieldName, value);
+      }
+    }
+    const withDefaults = applyCreateDefaults(model, recordOf(scalars));
+    const row = this.toColumnMap(model, withDefaults);
+    const returning = idFields(model);
+    const stmt = compileInsert(model, row, this.ctx(), returning);
+    const result = await this.exec(stmt.sql);
+    const keys = this.keyValues(model, result[0] ?? {}, withDefaults);
+    for (const [field, op] of children) {
+      await this.writeChildren(model, keys, field, op);
+    }
+    return keys;
+  }
+  /** Update rows matched by `where` (with nested writes). */
+  async updateRow(model, where, data, keys) {
+    const { scalars, owning, children } = this.partition(model, data, true);
+    for (const [field, op] of owning) {
+      for (const [fieldName, value] of await this.resolveOwningForUpdate(
+        model,
+        field,
+        op
+      )) {
+        scalars.set(fieldName, value);
+      }
+    }
+    const withDefaults = applyUpdateDefaults(model, recordOf(scalars));
+    const assignments = this.toUpdateColumnMap(model, withDefaults);
+    if (assignments.size > 0) {
+      const stmt = compileUpdate(model, where, assignments, this.ctx());
+      await this.exec(stmt.sql);
+    }
+    for (const [field, op] of children) {
+      await this.writeChildren(model, keys, field, op);
+    }
+  }
+  /**
+   * Scalar-only bulk update (for `updateMany`). Atomic operators are supported;
+   * nested relation writes are rejected, matching Prisma's `updateMany`.
+   */
+  async updateManyRows(model, where, data) {
+    for (const key of Object.keys(data)) {
+      const field = model.fields.find((f) => f.name === key);
+      if (field?.kind === "object") {
+        throw new QueryValidationError(
+          `updateMany does not support nested relation writes ('${model.name}.${key}'). Use update() per record.`
+        );
+      }
+    }
+    const withDefaults = applyUpdateDefaults(model, data);
+    const assignments = this.toUpdateColumnMap(model, withDefaults);
+    if (assignments.size > 0) {
+      const stmt = compileUpdate(model, where, assignments, this.ctx());
+      await this.exec(stmt.sql);
+    }
+  }
+  // ---- partition & mapping ------------------------------------------------
+  partition(model, data, isUpdate = false) {
+    const scalars = /* @__PURE__ */ new Map();
+    const owning = [];
+    const children = [];
+    for (const [key, value] of Object.entries(data)) {
+      if (value === void 0) continue;
+      const field = model.fields.find((f) => f.name === key);
+      if (!field) {
+        throw new QueryValidationError(
+          `Unknown field '${key}' on model '${model.name}'.`
+        );
+      }
+      if (field.kind !== "object") {
+        scalars.set(key, value);
+        continue;
+      }
+      if (!isPlainObject(value)) {
+        throw new QueryValidationError(
+          `Relation '${model.name}.${key}' expects a nested write object.`
+        );
+      }
+      const rel = resolveRelation(this.schema, model, field);
+      if (rel.owns) owning.push([field, value]);
+      else children.push([field, value]);
+    }
+    return { scalars, owning, children };
+  }
+  toColumnMap(model, record) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(record)) {
+      const field = model.fields.find((f) => f.name === name);
+      if (!field || field.kind === "object") continue;
+      if (isAutoincrement(field) && (value === void 0 || value === null)) {
+        continue;
+      }
+      out.set(fieldColumn(field), this.dialect.coerceValue(value));
+    }
+    return out;
+  }
+  /**
+   * Build UPDATE assignments, interpreting atomic scalar operators:
+   * `{ set }`, `{ increment }`, `{ decrement }`, `{ multiply }`, `{ divide }`.
+   * A bare value is a plain `set`.
+   */
+  toUpdateColumnMap(model, record) {
+    const out = /* @__PURE__ */ new Map();
+    for (const [name, value] of Object.entries(record)) {
+      const field = model.fields.find((f) => f.name === name);
+      if (!field || field.kind === "object") continue;
+      out.set(fieldColumn(field), this.toColumnUpdate(field, value));
+    }
+    return out;
+  }
+  toColumnUpdate(field, value) {
+    const coerce = (v) => this.dialect.coerceValue(v);
+    if (isPlainObject(value)) {
+      if ("set" in value) return { kind: "set", value: coerce(value.set) };
+      const arith = ARITH_OPS.find((op) => op.key in value);
+      if (arith) {
+        requireNumeric(field, arith.key);
+        return { kind: "arith", op: arith.op, value: coerce(value[arith.key]) };
+      }
+    }
+    return { kind: "set", value: coerce(value) };
+  }
+  keyValues(model, returnedRow, writtenData) {
+    const out = {};
+    for (const f of idFields(model)) {
+      out[f.name] = returnedRow[f.name] ?? returnedRow[fieldColumn(f)] ?? writtenData[f.name];
+    }
+    return out;
+  }
+  // ---- owning-side relations ---------------------------------------------
+  async resolveOwning(model, field, op) {
+    const rel = resolveRelation(this.schema, model, field);
+    if (op.connect) {
+      const ref = await this.lookupReference(rel, op.connect);
+      return this.mapFkByField(rel, ref);
+    }
+    if (op.create) {
+      const childKeys = await this.create(
+        rel.relatedModel,
+        op.create
+      );
+      return this.mapFkByField(rel, childKeys);
+    }
+    if (op.connectOrCreate) {
+      const spec = op.connectOrCreate;
+      const existing = await this.tryLookupReference(rel, spec.where);
+      const ref = existing ?? await this.create(rel.relatedModel, spec.create);
+      return this.mapFkByField(rel, ref);
+    }
+    throw new QueryValidationError(
+      `Unsupported nested write on '${model.name}.${field.name}'.`
+    );
+  }
+  async resolveOwningForUpdate(model, field, op) {
+    if (op.disconnect) {
+      const rel = resolveRelation(this.schema, model, field);
+      return rel.fromFields.map((name) => [name, null]);
+    }
+    return this.resolveOwning(model, field, op);
+  }
+  /** [localFieldName, value] pairs from the referenced model's key values. */
+  mapFkByField(rel, refValues) {
+    return rel.fromFields.map((fromField, i) => {
+      const toField = rel.toFields[i];
+      return [fromField, this.dialect.coerceValue(refValues[toField] ?? null)];
+    });
+  }
+  async lookupReference(rel, where) {
+    const found = await this.tryLookupReference(rel, where);
+    if (!found) throw new RecordNotFoundError(rel.relatedModel.name);
+    return found;
+  }
+  async tryLookupReference(rel, where) {
+    const fields = rel.toFields.map((n) => requireField(rel.relatedModel, n));
+    const stmt = this.selectKeys(rel.relatedModel, fields, where);
+    const rows = await this.exec(stmt);
+    return rows[0] ?? null;
+  }
+  selectKeys(model, fields, where) {
+    const d = this.dialect;
+    const alias = "t0";
+    const sql = new Sql();
+    sql.push("SELECT FIRST 1 ");
+    sql.push(
+      fields.map((f) => `${d.quoteRef(alias, fieldColumn(f))} AS ${d.quoteId(f.name)}`).join(", ")
+    );
+    sql.push(` FROM ${d.quoteId(modelTable(model))} ${d.quoteId(alias)}`);
+    const cond = compileWhere(model, alias, where, this.ctx());
+    if (!cond.isEmpty()) sql.push(" WHERE ").append(cond);
+    return sql;
+  }
+  // ---- child-side relations ----------------------------------------------
+  async writeChildren(parentModel, parentKeys, field, op) {
+    const rel = resolveRelation(this.schema, parentModel, field);
+    const fkColumns = rel.toColumns.map((toCol, i) => {
+      const fromField = rel.fromFields[i];
+      return [toCol, this.dialect.coerceValue(parentKeys[fromField] ?? null)];
+    });
+    for (const childData of toArray(op.create)) {
+      await this.create(rel.relatedModel, { ...childData, ...fkRecord(rel, parentKeys) });
+    }
+    for (const where of toArray(op.connect)) {
+      await this.setChildForeignKey(rel, where, fkColumns);
+    }
+    if (op.set !== void 0) {
+      await this.clearChildren(rel, parentKeys);
+      for (const where of toArray(op.set)) {
+        await this.setChildForeignKey(rel, where, fkColumns);
+      }
+    }
+    for (const where of toArray(op.disconnect)) {
+      await this.setChildForeignKey(
+        rel,
+        where,
+        rel.toColumns.map((c) => [c, null])
+      );
+    }
+    for (const where of toArray(op.delete)) {
+      const stmt = compileDelete(rel.relatedModel, where, this.ctx());
+      await this.exec(stmt.sql);
+    }
+  }
+  async setChildForeignKey(rel, where, fkColumns) {
+    const assignments = setAssignments(new Map(fkColumns));
+    const stmt = compileUpdate(rel.relatedModel, where, assignments, this.ctx());
+    await this.exec(stmt.sql);
+  }
+  async clearChildren(rel, parentKeys) {
+    const matchWhere = {};
+    rel.toFields.forEach((toField, i) => {
+      const fromField = rel.fromFields[i];
+      matchWhere[toField] = parentKeys[fromField];
+    });
+    const assignments = setAssignments(
+      new Map(
+        rel.toColumns.map((c) => [c, null])
+      )
+    );
+    const stmt = compileUpdate(rel.relatedModel, matchWhere, assignments, this.ctx());
+    await this.exec(stmt.sql);
+  }
+};
+var ARITH_OPS = [
+  { key: "increment", op: "+" },
+  { key: "decrement", op: "-" },
+  { key: "multiply", op: "*" },
+  { key: "divide", op: "/" }
+];
+var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "BigInt", "Float", "Decimal"]);
+function requireNumeric(field, op) {
+  if (!NUMERIC_TYPES.has(field.type)) {
+    throw new QueryValidationError(
+      `Operator '${op}' is only valid on numeric fields, not '${field.name}' (${field.type}).`
+    );
+  }
+}
+function requireField(model, name) {
+  const f = model.fields.find((x) => x.name === name);
+  if (!f) {
+    throw new QueryValidationError(`Field '${name}' not found on '${model.name}'.`);
+  }
+  return f;
+}
+function fkRecord(rel, parentKeys) {
+  const out = {};
+  rel.toFields.forEach((toField, i) => {
+    const fromField = rel.fromFields[i];
+    out[toField] = parentKeys[fromField];
+  });
+  return out;
+}
+function recordOf(scalars) {
+  const out = {};
+  for (const [k, v] of scalars) out[k] = v;
+  return out;
+}
+function toArray(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+// src/query/engine.ts
+function readShape(args) {
+  return { select: args.select, include: args.include, omit: args.omit };
+}
+var QueryEngine = class {
+  constructor(schema, dialect, driver) {
+    this.schema = schema;
+    this.dialect = dialect;
+    this.driver = driver;
+  }
+  schema;
+  dialect;
+  driver;
+  model(name) {
+    const model = findModel(this.schema, name);
+    if (!model) throw new QueryValidationError(`Unknown model '${name}'.`);
+    return model;
+  }
+  run(fn, options) {
+    return this.driver.transaction(fn, options);
+  }
+  execOn(tx) {
+    return (sql) => tx.query(sql.text, sql.params);
+  }
+  // ---- reads --------------------------------------------------------------
+  findMany(name, args = {}) {
+    const model = this.model(name);
+    return this.run((tx) => this.readMany(model, args, this.execOn(tx)));
+  }
+  async findFirst(name, args = {}) {
+    const rows = await this.findMany(name, { ...args, take: 1 });
+    return rows[0] ?? null;
+  }
+  async findFirstOrThrow(name, args = {}) {
+    const row = await this.findFirst(name, args);
+    if (!row) throw new RecordNotFoundError(name);
+    return row;
+  }
+  async findUnique(name, args) {
+    const model = this.model(name);
+    this.assertUniqueWhere(model, args.where);
+    const rows = await this.run(
+      (tx) => this.readMany(
+        model,
+        { where: args.where, select: args.select, include: args.include, take: 1 },
+        this.execOn(tx)
+      )
+    );
+    return rows[0] ?? null;
+  }
+  async findUniqueOrThrow(name, args) {
+    const row = await this.findUnique(name, args);
+    if (!row) throw new RecordNotFoundError(name);
+    return row;
+  }
+  // ---- aggregations -------------------------------------------------------
+  count(name, args = {}) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const stmt = compileCount(model, args.where, newContext(this.schema, this.dialect), {
+        take: args.take,
+        skip: args.skip
+      });
+      const rows = await tx.query(stmt.text, stmt.params);
+      return Number(rows[0]?._count ?? 0);
+    });
+  }
+  aggregate(name, args = {}) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const stmt = compileAggregate(model, args, newContext(this.schema, this.dialect));
+      const rows = await tx.query(stmt.text, stmt.params);
+      return reshapeAggregate(rows[0] ?? {});
+    });
+  }
+  groupBy(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const { sql } = compileGroupBy(model, args, newContext(this.schema, this.dialect));
+      const rows = await tx.query(sql.text, sql.params);
+      return rows.map((r) => reshapeGroupRow(model, args.by, r));
+    });
+  }
+  // ---- writes -------------------------------------------------------------
+  create(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const writer = new WriteProcessor(this.schema, this.dialect, this.execOn(tx));
+      const keys = await writer.create(model, args.data);
+      return this.readBack(model, keys, readShape(args), this.execOn(tx));
+    });
+  }
+  createMany(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const writer = new WriteProcessor(this.schema, this.dialect, this.execOn(tx));
+      let count = 0;
+      for (const data of args.data) {
+        await writer.create(model, data);
+        count++;
+      }
+      return { count };
+    });
+  }
+  /** Like createMany, but returns the created records (no nested relations). */
+  createManyAndReturn(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const writer = new WriteProcessor(this.schema, this.dialect, exec);
+      const out = [];
+      const shape = { select: args.select, omit: args.omit };
+      for (const data of args.data) {
+        const keys = await writer.create(model, data);
+        out.push(await this.readBack(model, keys, shape, exec));
+      }
+      return out;
+    });
+  }
+  update(name, args) {
+    const model = this.model(name);
+    this.assertUniqueWhere(model, args.where);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const target = await this.requireOne(model, args.where, exec);
+      const keys = this.pickKeys(model, target);
+      const writer = new WriteProcessor(this.schema, this.dialect, exec);
+      await writer.updateRow(model, args.where, args.data, keys);
+      return this.readBack(model, keys, readShape(args), exec);
+    });
+  }
+  updateMany(name, args) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const count = await this.countMatching(model, args.where, exec);
+      const writer = new WriteProcessor(this.schema, this.dialect, exec);
+      await writer.updateManyRows(model, args.where, args.data);
+      return { count };
+    });
+  }
+  upsert(name, args) {
+    const model = this.model(name);
+    this.assertUniqueWhere(model, args.where);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const existing = await this.findOneRaw(model, args.where, exec);
+      const writer = new WriteProcessor(this.schema, this.dialect, exec);
+      if (existing) {
+        const keys2 = this.pickKeys(model, existing);
+        await writer.updateRow(model, args.where, args.update, keys2);
+        return this.readBack(model, keys2, readShape(args), exec);
+      }
+      const keys = await writer.create(model, args.create);
+      return this.readBack(model, keys, readShape(args), exec);
+    });
+  }
+  delete(name, args) {
+    const model = this.model(name);
+    this.assertUniqueWhere(model, args.where);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const row = await this.readBackOne(model, args.where, readShape(args), exec);
+      if (!row) throw new RecordNotFoundError(name);
+      const stmt = compileDelete(model, args.where, newContext(this.schema, this.dialect));
+      await exec(stmt.sql);
+      return row;
+    });
+  }
+  deleteMany(name, args = {}) {
+    const model = this.model(name);
+    return this.run(async (tx) => {
+      const exec = this.execOn(tx);
+      const count = await this.countMatching(model, args.where, exec);
+      const stmt = compileDelete(model, args.where, newContext(this.schema, this.dialect));
+      await exec(stmt.sql);
+      return { count };
+    });
+  }
+  // ---- read pipeline ------------------------------------------------------
+  async readMany(model, args, exec, forceKeep = []) {
+    const relations = this.readRelations(model, args.select, args.include);
+    const countFields = this.readCountRelations(model, args.select, args.include);
+    const selectedScalars = applyOmit(
+      model,
+      selectedScalarNames(model, args.select),
+      args.omit
+    );
+    const distinctFields = normalizeDistinct(model, args.distinct);
+    const useWindowDistinct = distinctFields.length > 0 && this.dialect.supportsWindowFunctions;
+    const memoryPaginate = distinctFields.length > 0 && !useWindowDistinct;
+    const { where, orderBy } = applyCursor(model, args, distinctFields);
+    const relationKeyFields = uniq(
+      [...relations.map((r) => r.field), ...countFields].flatMap(
+        (field) => resolveRelation(this.schema, model, field).fromFields
+      )
+    );
+    const internalKeys = uniq([
+      ...relationKeyFields,
+      ...distinctFields
+      // fetched for de-dup; stripped below if not selected
+    ]);
+    const projectionNames = uniq([
+      ...selectedScalars ?? scalarFields(model).map((f) => f.name),
+      ...internalKeys,
+      ...forceKeep
+    ]);
+    const projection = projectionNames.map((n) => fieldByName(model, n));
+    const findOptions = {
+      where,
+      orderBy,
+      take: memoryPaginate ? void 0 : args.take,
+      skip: memoryPaginate ? void 0 : args.skip
+    };
+    const stmt = useWindowDistinct ? compileDistinctFindMany(
+      model,
+      findOptions,
+      projection,
+      distinctFields.map((n) => fieldByName(model, n)),
+      newContext(this.schema, this.dialect)
+    ) : compileFindMany(
+      model,
+      findOptions,
+      projection,
+      newContext(this.schema, this.dialect)
+    );
+    const rawRows = await exec(stmt.sql);
+    let rows = rawRows.map((r) => coerceRow(r, projection));
+    if (memoryPaginate) {
+      rows = dedupeBy(rows, distinctFields);
+      rows = applyPagination(rows, args.take, args.skip);
+    }
+    for (const relation of relations) {
+      await this.loadRelation(model, rows, relation, exec);
+    }
+    if (countFields.length > 0) {
+      await this.loadCounts(model, rows, countFields, exec);
+    }
+    if (selectedScalars) {
+      const visible = /* @__PURE__ */ new Set([...selectedScalars, ...forceKeep]);
+      for (const row of rows) {
+        for (const name of internalKeys) {
+          if (!visible.has(name)) delete row[name];
+        }
+      }
+    }
+    return rows;
+  }
+  async loadRelation(parentModel, parentRows, relation, exec) {
+    if (parentRows.length === 0) return;
+    const rel = resolveRelation(this.schema, parentModel, relation.field);
+    const fieldName = relation.field.name;
+    const { fromFields, toFields } = rel;
+    const parentTuples = uniqueTuples(parentRows, fromFields);
+    const grouped = /* @__PURE__ */ new Map();
+    if (parentTuples.length > 0) {
+      const childWhere = relationKeyWhere(
+        toFields,
+        parentTuples,
+        relation.args.where
+      );
+      const childRows = await this.readMany(
+        rel.relatedModel,
+        {
+          where: childWhere,
+          orderBy: relation.args.orderBy,
+          select: relation.args.select,
+          include: relation.args.include,
+          // take/skip on to-many are applied per parent below; skip here.
+          ...rel.isList ? {} : { take: relation.args.take, skip: relation.args.skip }
+        },
+        exec,
+        toFields
+      );
+      for (const child of childRows) {
+        const k = tupleKey(child, toFields);
+        const list = grouped.get(k) ?? [];
+        list.push(child);
+        grouped.set(k, list);
+      }
+    }
+    const visible = selectedScalarNames(rel.relatedModel, relation.args.select);
+    const stripFields = visible ? toFields.filter((f) => !visible.has(f)) : [];
+    for (const parent of parentRows) {
+      const k = tupleKey(parent, fromFields);
+      let matches = grouped.get(k) ?? [];
+      if (rel.isList && (relation.args.take != null || relation.args.skip != null)) {
+        matches = applyPagination(matches, relation.args.take, relation.args.skip);
+      }
+      const attached = stripFields.length ? matches.map((m) => omitAll(m, stripFields)) : matches;
+      parent[fieldName] = rel.isList ? attached : attached[0] ?? null;
+    }
+  }
+  readRelations(model, select, include) {
+    const out = [];
+    const add = (key, value) => {
+      if (!value) return;
+      const field = model.fields.find((f) => f.name === key && f.kind === "object");
+      if (!field) return;
+      out.push({ field, args: typeof value === "object" ? value : {} });
+    };
+    if (include) for (const [k, v] of Object.entries(include)) add(k, v);
+    if (select) {
+      for (const [k, v] of Object.entries(select)) {
+        const field = model.fields.find((f) => f.name === k);
+        if (field?.kind === "object") add(k, v);
+      }
+    }
+    return out;
+  }
+  /**
+   * Resolve which to-many relations to count for `_count` in select/include.
+   * `_count: true` counts every list relation; `_count: { select: { rel } }`
+   * counts the named ones.
+   */
+  readCountRelations(model, select, include) {
+    const spec = include?._count ?? select?._count;
+    if (!spec) return [];
+    const listRelations = model.fields.filter(
+      (f) => f.kind === "object" && f.isList
+    );
+    if (spec === true) return listRelations;
+    const selected = spec.select;
+    if (!selected) return listRelations;
+    return listRelations.filter((f) => selected[f.name]);
+  }
+  /** Attach a `_count` object to each row with per-relation child counts. */
+  async loadCounts(model, rows, countFields, exec) {
+    for (const row of rows) row._count = {};
+    for (const field of countFields) {
+      const rel = resolveRelation(this.schema, model, field);
+      const tuples = uniqueTuples(rows, rel.fromFields);
+      const grouped = /* @__PURE__ */ new Map();
+      if (tuples.length > 0) {
+        const where = relationKeyWhere(rel.toFields, tuples, void 0);
+        const { sql } = compileGroupBy(
+          rel.relatedModel,
+          { by: rel.toFields, _count: true, where },
+          newContext(this.schema, this.dialect)
+        );
+        const countRows = await exec(sql);
+        for (const cr of countRows) {
+          grouped.set(tupleKey(cr, rel.toFields), Number(cr._count_all ?? 0));
+        }
+      }
+      for (const row of rows) {
+        const count = grouped.get(tupleKey(row, rel.fromFields)) ?? 0;
+        row._count[field.name] = count;
+      }
+    }
+  }
+  // ---- read-back & helpers ------------------------------------------------
+  async readBack(model, keys, shape, exec) {
+    const where = keysToWhere(model, keys);
+    const row = await this.readBackOne(model, where, shape, exec);
+    if (!row) throw new RecordNotFoundError(model.name);
+    return row;
+  }
+  async readBackOne(model, where, shape, exec) {
+    const rows = await this.readMany(
+      model,
+      { where, select: shape.select, include: shape.include, omit: shape.omit, take: 1 },
+      exec
+    );
+    return rows[0] ?? null;
+  }
+  async requireOne(model, where, exec) {
+    const row = await this.findOneRaw(model, where, exec);
+    if (!row) throw new RecordNotFoundError(model.name);
+    return row;
+  }
+  async findOneRaw(model, where, exec) {
+    const rows = await this.readMany(model, { where, take: 1 }, exec);
+    return rows[0] ?? null;
+  }
+  async countMatching(model, where, exec) {
+    const stmt = compileCount(model, where, newContext(this.schema, this.dialect));
+    const rows = await exec(stmt);
+    return Number(rows[0]?._count ?? 0);
+  }
+  pickKeys(model, row) {
+    const out = {};
+    for (const f of idFields(model)) out[f.name] = row[f.name];
+    return out;
+  }
+  assertUniqueWhere(model, where) {
+    if (!where || Object.keys(where).length === 0) {
+      throw new QueryValidationError(
+        `A unique 'where' is required for this operation on '${model.name}'.`
+      );
+    }
+  }
+};
+function fieldByName(model, name) {
+  const f = model.fields.find((x) => x.name === name);
+  if (!f) throw new QueryValidationError(`Field '${name}' not found on '${model.name}'.`);
+  return f;
+}
+function selectedScalarNames(model, select) {
+  if (!select) return null;
+  const names = /* @__PURE__ */ new Set();
+  for (const [k, v] of Object.entries(select)) {
+    if (!v) continue;
+    const field = model.fields.find((f) => f.name === k);
+    if (field && field.kind !== "object") names.add(k);
+  }
+  return names;
+}
+function applyOmit(model, selected, omit) {
+  if (selected || !omit) return selected;
+  const omitted = new Set(
+    Object.entries(omit).filter(([, v]) => v).map(([k]) => k)
+  );
+  if (omitted.size === 0) return null;
+  return new Set(
+    scalarFields(model).map((f) => f.name).filter((n) => !omitted.has(n))
+  );
+}
+function keysToWhere(model, keys) {
+  const where = {};
+  for (const f of idFields(model)) where[f.name] = keys[f.name];
+  return where;
+}
+function keyOf(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+function tupleKey(row, fields) {
+  return fields.map((f) => keyOf(row[f])).join("\0");
+}
+function uniqueTuples(rows, fields) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of rows) {
+    const tuple = fields.map((f) => row[f]);
+    if (tuple.some((v) => v === null || v === void 0)) continue;
+    const key = tuple.map(keyOf).join("\0");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(tuple);
+  }
+  return out;
+}
+function relationKeyWhere(toFields, parentTuples, baseWhere) {
+  const base = baseWhere ?? {};
+  if (toFields.length === 1) {
+    const field = toFields[0];
+    return { ...base, [field]: { in: parentTuples.map((t) => t[0]) } };
+  }
+  const or = parentTuples.map((tuple) => {
+    const cond = {};
+    toFields.forEach((f, i) => {
+      cond[f] = tuple[i];
+    });
+    return cond;
+  });
+  if (Object.keys(base).length === 0) return { OR: or };
+  return { AND: [base, { OR: or }] };
+}
+function omitAll(obj, keys) {
+  const out = { ...obj };
+  for (const k of keys) delete out[k];
+  return out;
+}
+function applyPagination(rows, take, skip) {
+  const start = skip ?? 0;
+  const end = take != null ? start + take : void 0;
+  return rows.slice(start, end);
+}
+function normalizeDistinct(model, distinct) {
+  if (!distinct || distinct.length === 0) return [];
+  for (const name of distinct) {
+    const field = model.fields.find((f) => f.name === name);
+    if (!field || field.kind === "object") {
+      throw new QueryValidationError(
+        `Cannot apply distinct on '${model.name}.${name}' (not a scalar field).`
+      );
+    }
+  }
+  return uniq(distinct);
+}
+function dedupeBy(rows, fields) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of rows) {
+    const key = tupleKey(row, fields);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(row);
+  }
+  return out;
+}
+function applyCursor(model, args, _distinctFields) {
+  if (!args.cursor || Object.keys(args.cursor).length === 0) {
+    return { where: args.where, orderBy: args.orderBy };
+  }
+  const entries = Object.entries(args.cursor).filter(([, v]) => v !== void 0);
+  if (entries.length === 0) return { where: args.where, orderBy: args.orderBy };
+  const fields = entries.map(([name, value]) => {
+    if (!model.fields.some((f) => f.name === name && f.kind !== "object")) {
+      throw new QueryValidationError(
+        `Cursor field '${model.name}.${name}' must be a scalar field.`
+      );
+    }
+    return { name, value, direction: directionForField(args.orderBy, name) ?? "asc" };
+  });
+  const cursorCond = keysetCondition(fields);
+  const where = args.where ? { AND: [args.where, cursorCond] } : cursorCond;
+  const orderBy = args.orderBy ?? fields.map((f) => ({ [f.name]: f.direction }));
+  return { where, orderBy };
+}
+function keysetCondition(fields) {
+  const clauses = [];
+  for (let i = 0; i < fields.length; i++) {
+    const clause = {};
+    for (let j = 0; j < i; j++) {
+      clause[fields[j].name] = fields[j].value;
+    }
+    const last = i === fields.length - 1;
+    const f = fields[i];
+    const op = comparator(f.direction, last);
+    clause[f.name] = { [op]: f.value };
+    clauses.push(clause);
+  }
+  return clauses.length === 1 ? clauses[0] : { OR: clauses };
+}
+function comparator(direction, inclusive) {
+  if (direction === "desc") return inclusive ? "lte" : "lt";
+  return inclusive ? "gte" : "gt";
+}
+function directionForField(orderBy, field) {
+  if (!orderBy) return void 0;
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  for (const obj of list) {
+    const dir = obj[field];
+    if (dir === "asc" || dir === "desc") return dir;
+  }
+  return void 0;
+}
+function reshapeAggregate(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "_count_all") {
+      out._count ??= {};
+      out._count._all = Number(value);
+      continue;
+    }
+    const m = /^(_count|_sum|_avg|_min|_max)_(.+)$/.exec(key);
+    if (m) {
+      const group = out[m[1]] ??= {};
+      group[m[2]] = value === null ? null : Number(value);
+    }
+  }
+  return out;
+}
+function reshapeGroupRow(model, by, row) {
+  const out = {};
+  const groupFields = scalarFields(model).filter((f) => by.includes(f.name));
+  for (const f of groupFields) {
+    out[f.name] = f.name in row ? coerceField(row[f.name], f) : row[f.name];
+  }
+  const aggregates = reshapeAggregate(row);
+  return { ...out, ...aggregates };
+}
+function coerceField(value, field) {
+  return coerceRow({ [field.name]: value }, [field])[field.name];
+}
+
+// src/client/runtime.ts
+var RECORD_OPS = /* @__PURE__ */ new Set([
+  "findMany",
+  "findFirst",
+  "findFirstOrThrow",
+  "findUnique",
+  "findUniqueOrThrow",
+  "create",
+  "createManyAndReturn",
+  "update",
+  "upsert",
+  "delete"
+]);
+var ALL_OPS = [
+  "findMany",
+  "findFirst",
+  "findFirstOrThrow",
+  "findUnique",
+  "findUniqueOrThrow",
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "update",
+  "updateMany",
+  "upsert",
+  "delete",
+  "deleteMany",
+  "count",
+  "aggregate",
+  "groupBy"
+];
+var FLUENT_OPS = /* @__PURE__ */ new Set([
+  "findUnique",
+  "findUniqueOrThrow",
+  "findFirst",
+  "findFirstOrThrow"
+]);
+function buildDelegate(ctx, modelName) {
+  const model = findModel(ctx.schema, modelName);
+  const delegate = {};
+  for (const operation of ALL_OPS) {
+    delegate[operation] = (args = {}) => runOperation(ctx, modelName, operation, args, delegate);
+  }
+  for (const ext of ctx.extensions) {
+    const methods = {
+      ...ext.model?.$allModels ?? {},
+      ...ext.model?.[modelName] ?? {}
+    };
+    for (const [name, fn] of Object.entries(methods)) {
+      delegate[name] = (...args) => fn.apply(delegate, args);
+    }
+  }
+  void model;
+  return delegate;
+}
+function runOperation(ctx, modelName, operation, args, delegate) {
+  const base = async (a) => {
+    const expanded = expandComputedSelect(ctx, modelName, operation, a);
+    const raw = await runMiddleware(ctx, modelName, operation, expanded.args);
+    return applyResultExtensions(ctx, modelName, operation, raw, expanded.computeOnly);
+  };
+  const hooks = gatherQueryHooks(ctx, modelName, operation);
+  const run = composeHooks(hooks, modelName, operation, base);
+  if (FLUENT_OPS.has(operation)) {
+    return makeFluent(ctx, modelName, args, () => run(args));
+  }
+  void delegate;
+  return run(args);
+}
+function gatherQueryHooks(ctx, model, operation) {
+  const hooks = [];
+  for (const ext of ctx.extensions) {
+    const q = ext.query;
+    if (!q) continue;
+    pushHook(hooks, q[model], operation);
+    pushHook(hooks, q.$allModels, operation);
+  }
+  return hooks;
+}
+function pushHook(hooks, map, operation) {
+  if (!map) return;
+  if (map[operation]) hooks.push(map[operation]);
+  if (map.$allOperations) hooks.push(map.$allOperations);
+}
+function composeHooks(hooks, model, operation, base) {
+  let next = base;
+  for (const hook of hooks) {
+    const inner = next;
+    next = (args) => hook({ model, operation, args, query: (a) => inner(a) });
+  }
+  return next;
+}
+function runMiddleware(ctx, model, action, args) {
+  const engine = ctx.engine;
+  const engineCall = (a) => engine[a.action](model, a.args);
+  let next = engineCall;
+  for (const mw of ctx.middlewares) {
+    const inner = next;
+    next = (params) => mw(params, inner);
+  }
+  return next({ model, action, args });
+}
+function resultComputers(ctx, model) {
+  const out = [];
+  for (const ext of ctx.extensions) {
+    const r = ext.result?.[model];
+    if (!r) continue;
+    for (const [field, def] of Object.entries(r)) {
+      out.push({ field, compute: def.compute });
+    }
+  }
+  return out;
+}
+function applyResultExtensions(ctx, model, operation, value, computeFields) {
+  if (!RECORD_OPS.has(operation)) return value;
+  const computers = resultComputers(ctx, model).filter(
+    (c) => !computeFields || computeFields.has(c.field)
+  );
+  if (computers.length === 0) return value;
+  const compute = (rec) => {
+    if (!rec || typeof rec !== "object") return rec;
+    const record = rec;
+    for (const c of computers) {
+      try {
+        record[c.field] = c.compute(record);
+      } catch {
+      }
+    }
+    return record;
+  };
+  return Array.isArray(value) ? value.map(compute) : compute(value);
+}
+function expandComputedSelect(ctx, model, operation, args) {
+  const computers = resultComputers(ctx, model);
+  if (computers.length === 0) return { args, computeOnly: null };
+  const select = args.select;
+  if (!select) return { args, computeOnly: null };
+  const byField = new Map(
+    ctx.extensions.flatMap((e) => Object.entries(e.result?.[model] ?? {})).map(([f, def]) => [f, def])
+  );
+  const computeOnly = /* @__PURE__ */ new Set();
+  const newSelect = { ...select };
+  for (const key of Object.keys(select)) {
+    const def = byField.get(key);
+    if (!def) continue;
+    computeOnly.add(key);
+    delete newSelect[key];
+    for (const need of Object.keys(def.needs ?? {})) newSelect[need] = true;
+  }
+  if (computeOnly.size === 0) return { args, computeOnly: null };
+  return { args: { ...args, select: newSelect }, computeOnly };
+}
+function makeFluent(ctx, modelName, args, exec) {
+  const model = findModel(ctx.schema, modelName);
+  const where = args.where ?? {};
+  let cached = null;
+  const run = () => cached ??= exec();
+  const fluent = {
+    then: (res, rej) => run().then(res, rej),
+    catch: (rej) => run().catch(rej),
+    finally: (f) => run().finally(f)
+  };
+  for (const rel of relationFields(model)) {
+    fluent[rel.name] = (subArgs = {}) => traverse(ctx, model, rel, where, subArgs);
+  }
+  return fluent;
+}
+function traverse(ctx, model, rel, parentWhere, subArgs) {
+  const inverse = inverseField(ctx.schema, model, rel);
+  const relatedWhere = inverse ? inverse.isList ? { [inverse.name]: { some: parentWhere } } : { [inverse.name]: parentWhere } : {};
+  const where = subArgs.where ? { AND: [relatedWhere, subArgs.where] } : relatedWhere;
+  const findArgs = { ...subArgs, where };
+  if (rel.isList) {
+    return ctx.engine.findMany(rel.type, findArgs);
+  }
+  return makeFluent(
+    ctx,
+    rel.type,
+    { ...subArgs, where },
+    () => ctx.engine.findFirst(rel.type, findArgs)
+  );
+}
+function inverseField(schema, model, rel) {
+  const related = findModel(schema, rel.type);
+  if (!related) return void 0;
+  const candidates = related.fields.filter(
+    (f) => f.kind === "object" && f.type === model.name
+  );
+  if (rel.relation?.name) {
+    const byName = candidates.find((f) => f.relation?.name === rel.relation?.name);
+    if (byName) return byName;
+  }
+  return candidates[0];
+}
+
+// src/client/index.ts
+var EmberClientBase = class {
+  driver;
+  engine;
+  dialect;
+  schema;
+  connected = false;
+  /** Mutated by $extends (per instance) and $use (shared). */
+  extensions = [];
+  middlewares = [];
+  queryListeners = [];
+  baseLog;
+  constructor(options) {
+    this.schema = options.schema;
+    const url = options.datasourceUrl ?? resolveDatasourceUrl(options.schema, process.cwd());
+    if (!options.datasource && !url) {
+      throw new EmberError(
+        "No datasource configured. Provide datasourceUrl, datasource, or a datasource block with a resolvable url."
+      );
+    }
+    const config = options.datasource ?? parseConnectionUrl(url);
+    this.dialect = new FirebirdDialect({ version: config.version });
+    this.baseLog = buildLogger(options.log);
+    this.driver = createDriver(config, { onQuery: (e) => this.dispatchQuery(e) });
+    this.engine = new QueryEngine(options.schema, this.dialect, this.driver);
+    this.installDelegates();
+  }
+  dispatchQuery(event) {
+    this.baseLog?.(event);
+    for (const listener of this.queryListeners) listener(event);
+  }
+  delegateContext() {
+    return {
+      engine: this.engine,
+      schema: this.schema,
+      extensions: this.extensions,
+      middlewares: this.middlewares
+    };
+  }
+  /** (Re)define one delegate property per model using the current extensions. */
+  installDelegates() {
+    const ctx = this.delegateContext();
+    for (const model of this.schema.models) {
+      Object.defineProperty(this, lowerFirst(model.name), {
+        value: buildDelegate(ctx, model.name),
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  /**
+   * Prisma-style Client Extensions. Returns a new client (the original is
+   * unchanged) that shares the connection/engine but applies the extension's
+   * `result` / `model` / `query` / `client` definitions.
+   */
+  $extends(extension) {
+    const clone = Object.create(this);
+    clone.extensions = [...this.extensions, extension];
+    clone.installDelegates();
+    if (extension.client) {
+      for (const [key, value] of Object.entries(extension.client)) {
+        Object.defineProperty(clone, key, {
+          value: typeof value === "function" ? value.bind(clone) : value,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    return clone;
+  }
+  /** Prisma-style middleware: runs around every operation. */
+  $use(middleware) {
+    this.middlewares.push(middleware);
+  }
+  /** Subscribe to query events (mirrors the `log` callback). */
+  $on(event, listener) {
+    if (event === "query") this.queryListeners.push(listener);
+  }
+  /** Type-safe access to a delegate by model name. */
+  model(name) {
+    return this[lowerFirst(name)];
+  }
+  async $connect() {
+    if (this.connected) return;
+    await this.driver.connect();
+    this.connected = true;
+  }
+  async $disconnect() {
+    if (!this.connected) return;
+    await this.driver.disconnect();
+    this.connected = false;
+  }
+  $transaction(arg, options) {
+    if (Array.isArray(arg)) {
+      return this.driver.transaction(async () => {
+        const results = [];
+        for (const thunk of arg) results.push(await thunk(this));
+        return results;
+      }, options);
+    }
+    return this.driver.transaction(() => arg(this), options);
+  }
+  /** Execute a raw read query (returns rows) inside a transaction. */
+  $queryRawUnsafe(sql, ...params) {
+    return this.driver.transaction(
+      (tx) => tx.query(sql, params.map(toSqlValue))
+    );
+  }
+  /** Execute a raw write statement inside a transaction; returns affected rows when available. */
+  $executeRawUnsafe(sql, ...params) {
+    return this.driver.transaction(async (tx) => {
+      const rows = await tx.query(sql, params.map(toSqlValue));
+      return Array.isArray(rows) ? rows.length : 0;
+    });
+  }
+  /** Tagged-template raw query: `client.$queryRaw\`SELECT * FROM T WHERE id = ${id}\``. */
+  $queryRaw(strings, ...values) {
+    const { sql, params } = buildTemplate(strings, values);
+    return this.$queryRawUnsafe(sql, ...params);
+  }
+  $executeRaw(strings, ...values) {
+    const { sql, params } = buildTemplate(strings, values);
+    return this.$executeRawUnsafe(sql, ...params);
+  }
+};
+function buildTemplate(strings, values) {
+  let sql = "";
+  strings.forEach((part, i) => {
+    sql += part;
+    if (i < values.length) sql += "?";
+  });
+  return { sql, params: values };
+}
+function toSqlValue(v) {
+  return v;
+}
+function buildLogger(log) {
+  if (!log) return void 0;
+  if (typeof log === "function") return log;
+  return (e) => {
+    const params = e.params.length ? ` -- ${JSON.stringify(e.params)}` : "";
+    console.log(
+      `ember:query (${e.durationMs.toFixed(1)}ms, ${e.rowCount} rows) ${e.sql}${params}`
+    );
+  };
+}
+function createClient(options) {
+  return new EmberClientBase(options);
+}
+
+// src/introspect/firebird-meta.ts
+var trim = (v) => v == null ? "" : String(v).trim();
+var numOrNull = (v) => v == null ? null : Number(v);
+var FirebirdMetadataReader = class {
+  constructor(tx) {
+    this.tx = tx;
+  }
+  tx;
+  async tables() {
+    const rows = await this.tx.query(
+      `SELECT RDB$RELATION_NAME
+       FROM RDB$RELATIONS
+       WHERE RDB$VIEW_BLR IS NULL
+         AND (RDB$SYSTEM_FLAG IS NULL OR RDB$SYSTEM_FLAG = 0)
+       ORDER BY RDB$RELATION_NAME`
+    );
+    return rows.map((r) => trim(r["RDB$RELATION_NAME"]));
+  }
+  async columns() {
+    const rows = await this.tx.query(
+      `SELECT
+         rf.RDB$RELATION_NAME      AS TABLE_NAME,
+         rf.RDB$FIELD_NAME         AS FIELD_NAME,
+         rf.RDB$FIELD_POSITION     AS FIELD_POSITION,
+         rf.RDB$NULL_FLAG          AS NULL_FLAG,
+         rf.RDB$DEFAULT_SOURCE     AS DEFAULT_SOURCE,
+         rf.RDB$IDENTITY_TYPE      AS IDENTITY_TYPE,
+         f.RDB$FIELD_TYPE          AS FIELD_TYPE,
+         f.RDB$FIELD_SUB_TYPE      AS FIELD_SUB_TYPE,
+         f.RDB$FIELD_LENGTH        AS FIELD_LENGTH,
+         f.RDB$CHARACTER_LENGTH    AS CHAR_LENGTH,
+         f.RDB$FIELD_PRECISION     AS FIELD_PRECISION,
+         f.RDB$FIELD_SCALE         AS FIELD_SCALE
+       FROM RDB$RELATION_FIELDS rf
+       JOIN RDB$FIELDS f ON f.RDB$FIELD_NAME = rf.RDB$FIELD_SOURCE
+       JOIN RDB$RELATIONS r ON r.RDB$RELATION_NAME = rf.RDB$RELATION_NAME
+       WHERE r.RDB$VIEW_BLR IS NULL
+         AND (r.RDB$SYSTEM_FLAG IS NULL OR r.RDB$SYSTEM_FLAG = 0)
+       ORDER BY rf.RDB$RELATION_NAME, rf.RDB$FIELD_POSITION`
+    );
+    return rows.map((r) => ({
+      table: trim(r.TABLE_NAME),
+      name: trim(r.FIELD_NAME),
+      position: Number(r.FIELD_POSITION ?? 0),
+      fieldType: Number(r.FIELD_TYPE ?? 0),
+      fieldSubType: numOrNull(r.FIELD_SUB_TYPE),
+      length: numOrNull(r.FIELD_LENGTH),
+      charLength: numOrNull(r.CHAR_LENGTH),
+      precision: numOrNull(r.FIELD_PRECISION),
+      scale: numOrNull(r.FIELD_SCALE),
+      notNull: r.NULL_FLAG != null && Number(r.NULL_FLAG) === 1,
+      defaultSource: r.DEFAULT_SOURCE == null ? null : trim(r.DEFAULT_SOURCE),
+      isIdentity: r.IDENTITY_TYPE != null
+    }));
+  }
+  async constraints() {
+    const rows = await this.tx.query(
+      `SELECT
+         rc.RDB$CONSTRAINT_NAME    AS CONSTRAINT_NAME,
+         rc.RDB$CONSTRAINT_TYPE    AS CONSTRAINT_TYPE,
+         rc.RDB$RELATION_NAME      AS TABLE_NAME,
+         rc.RDB$INDEX_NAME         AS INDEX_NAME,
+         seg.RDB$FIELD_NAME        AS FIELD_NAME,
+         seg.RDB$FIELD_POSITION    AS SEG_POSITION,
+         refc.RDB$UPDATE_RULE      AS UPDATE_RULE,
+         refc.RDB$DELETE_RULE      AS DELETE_RULE,
+         refc.RDB$CONST_NAME_UQ    AS UQ_NAME
+       FROM RDB$RELATION_CONSTRAINTS rc
+       JOIN RDB$INDEX_SEGMENTS seg ON seg.RDB$INDEX_NAME = rc.RDB$INDEX_NAME
+       LEFT JOIN RDB$REF_CONSTRAINTS refc ON refc.RDB$CONSTRAINT_NAME = rc.RDB$CONSTRAINT_NAME
+       WHERE rc.RDB$CONSTRAINT_TYPE IN ('PRIMARY KEY', 'UNIQUE', 'FOREIGN KEY')
+       ORDER BY rc.RDB$CONSTRAINT_NAME, seg.RDB$FIELD_POSITION`
+    );
+    const byName = /* @__PURE__ */ new Map();
+    const uqByName = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const name = trim(r.CONSTRAINT_NAME);
+      let c = byName.get(name);
+      if (!c) {
+        c = {
+          table: trim(r.TABLE_NAME),
+          type: trim(r.CONSTRAINT_TYPE),
+          name,
+          indexName: r.INDEX_NAME == null ? null : trim(r.INDEX_NAME),
+          columns: []
+        };
+        if (c.type === "FOREIGN KEY") {
+          c.updateRule = trim(r.UPDATE_RULE) || void 0;
+          c.deleteRule = trim(r.DELETE_RULE) || void 0;
+          uqByName.set(name, trim(r.UQ_NAME));
+        }
+        byName.set(name, c);
+      }
+      const col = trim(r.FIELD_NAME);
+      if (col && !c.columns.includes(col)) c.columns.push(col);
+    }
+    for (const c of byName.values()) {
+      if (c.type !== "FOREIGN KEY") continue;
+      const uqName = uqByName.get(c.name);
+      if (!uqName) continue;
+      const target = byName.get(uqName);
+      if (target) {
+        c.references = { table: target.table, columns: [...target.columns] };
+      } else {
+        const resolved = await this.resolveConstraintColumns(uqName);
+        if (resolved) c.references = resolved;
+      }
+    }
+    return [...byName.values()];
+  }
+  async resolveConstraintColumns(constraintName2) {
+    const rows = await this.tx.query(
+      `SELECT rc.RDB$RELATION_NAME AS TABLE_NAME, seg.RDB$FIELD_NAME AS FIELD_NAME
+       FROM RDB$RELATION_CONSTRAINTS rc
+       JOIN RDB$INDEX_SEGMENTS seg ON seg.RDB$INDEX_NAME = rc.RDB$INDEX_NAME
+       WHERE rc.RDB$CONSTRAINT_NAME = ?
+       ORDER BY seg.RDB$FIELD_POSITION`,
+      [constraintName2]
+    );
+    if (rows.length === 0) return null;
+    return {
+      table: trim(rows[0].TABLE_NAME),
+      columns: rows.map((r) => trim(r.FIELD_NAME))
+    };
+  }
+};
+
+// src/introspect/type-map.ts
+var FB = {
+  SMALLINT: 7,
+  INTEGER: 8,
+  QUAD: 9,
+  FLOAT: 10,
+  DATE_LEGACY: 11,
+  DATE: 12,
+  TIME: 13,
+  CHAR: 14,
+  INT64: 16,
+  // BIGINT / numeric
+  BOOLEAN: 23,
+  DOUBLE: 27,
+  TIMESTAMP: 35,
+  VARCHAR: 37,
+  BLOB: 261
+};
+function mapColumnType(col) {
+  const scale = col.scale ?? 0;
+  switch (col.fieldType) {
+    case FB.SMALLINT:
+      return scale < 0 ? decimal(col) : { scalar: "Int", native: { name: "SmallInt", args: [] } };
+    case FB.INTEGER:
+      return scale < 0 ? decimal(col) : { scalar: "Int", native: { name: "Integer", args: [] } };
+    case FB.INT64:
+      return scale < 0 ? decimal(col) : { scalar: "BigInt", native: { name: "BigInt", args: [] } };
+    case FB.FLOAT:
+      return { scalar: "Float", native: { name: "Float", args: [] } };
+    case FB.DOUBLE:
+      return { scalar: "Float", native: { name: "DoublePrecision", args: [] } };
+    case FB.BOOLEAN:
+      return { scalar: "Boolean", native: { name: "Boolean", args: [] } };
+    case FB.CHAR:
+      return {
+        scalar: "String",
+        native: { name: "Char", args: col.charLength ? [col.charLength] : [] }
+      };
+    case FB.VARCHAR:
+      return {
+        scalar: "String",
+        native: { name: "VarChar", args: col.charLength ? [col.charLength] : [] }
+      };
+    case FB.DATE:
+    case FB.DATE_LEGACY:
+      return { scalar: "DateTime", native: { name: "Date", args: [] } };
+    case FB.TIME:
+      return { scalar: "DateTime", native: { name: "Time", args: [] } };
+    case FB.TIMESTAMP:
+      return { scalar: "DateTime", native: { name: "Timestamp", args: [] } };
+    case FB.BLOB:
+      return col.fieldSubType === 1 ? { scalar: "String", native: { name: "Text", args: [] } } : { scalar: "Bytes", native: { name: "Blob", args: [] } };
+    default:
+      return { scalar: "String" };
+  }
+}
+function decimal(col) {
+  const precision = col.precision ?? 18;
+  const scaleAbs = Math.abs(col.scale ?? 0);
+  return {
+    scalar: "Decimal",
+    native: { name: "Decimal", args: [precision, scaleAbs] }
+  };
+}
+
+// src/introspect/index.ts
+var Introspector = class {
+  constructor(driver) {
+    this.driver = driver;
+  }
+  driver;
+  async introspect(options = {}) {
+    const { tables, columns, constraints } = await this.driver.transaction(
+      async (tx) => {
+        const reader = new FirebirdMetadataReader(tx);
+        return {
+          tables: await reader.tables(),
+          columns: await reader.columns(),
+          constraints: await reader.constraints()
+        };
+      },
+      { isolation: "READ_COMMITTED_READ_ONLY" }
+    );
+    const columnsByTable = groupBy(columns, (c) => c.table);
+    const constraintsByTable = groupBy(constraints, (c) => c.table);
+    const modelNames = buildNameMap(tables);
+    const models = tables.map(
+      (table) => this.buildModel(
+        table,
+        modelNames,
+        columnsByTable.get(table) ?? [],
+        constraintsByTable.get(table) ?? []
+      )
+    );
+    addRelations(models, modelNames, constraints);
+    const enums = [];
+    const doc = {
+      generators: [
+        { name: "client", provider: "ember-client-js", output: "../generated", config: {} }
+      ],
+      models,
+      enums
+    };
+    if (options.datasource) {
+      doc.datasource = {
+        name: options.datasource.name,
+        provider: options.datasource.provider,
+        url: options.datasource.envVar ? { kind: "env", value: options.datasource.envVar } : { kind: "literal", value: options.datasource.url ?? "" }
+      };
+    }
+    return doc;
+  }
+  buildModel(table, modelNames, columns, constraints) {
+    const modelName = modelNames.get(table);
+    const pk = constraints.find((c) => c.type === "PRIMARY KEY");
+    const uniques = constraints.filter((c) => c.type === "UNIQUE");
+    const fieldNameMap = buildNameMap(columns.map((c) => c.name), camelCase);
+    const fields = columns.map(
+      (col) => buildField(col, fieldNameMap, pk, uniques)
+    );
+    const model = {
+      name: modelName,
+      dbName: modelName !== table ? table : void 0,
+      fields,
+      primaryKey: pk && pk.columns.length > 1 ? pk.columns.map((c) => fieldNameMap.get(c)) : [],
+      uniqueIndexes: uniques.filter((u) => u.columns.length > 1).map((u) => ({ fields: u.columns.map((c) => fieldNameMap.get(c)) })),
+      indexes: []
+    };
+    return model;
+  }
+};
+function buildField(col, fieldNameMap, pk, uniques) {
+  const fieldName = fieldNameMap.get(col.name);
+  const mapped = mapColumnType(col);
+  const isSingleIdCol = !!pk && pk.columns.length === 1 && pk.columns[0] === col.name;
+  const isSingleUnique = uniques.some(
+    (u) => u.columns.length === 1 && u.columns[0] === col.name
+  );
+  const field = {
+    name: fieldName,
+    type: mapped.scalar,
+    kind: "scalar",
+    isList: false,
+    isRequired: col.notNull || isSingleIdCol,
+    isId: isSingleIdCol,
+    isUnique: isSingleUnique,
+    isUpdatedAt: false,
+    dbName: fieldName !== col.name ? col.name : void 0,
+    nativeType: mapped.native,
+    default: parseDefault(col)
+  };
+  return field;
+}
+function parseDefault(col) {
+  if (col.isIdentity) return { function: { name: "autoincrement", args: [] } };
+  if (!col.defaultSource) return void 0;
+  const src = col.defaultSource.replace(/^DEFAULT\s+/i, "").trim();
+  if (/^CURRENT_TIMESTAMP/i.test(src)) return { function: { name: "now", args: [] } };
+  if (/^(TRUE|FALSE)$/i.test(src)) return { literal: /^TRUE$/i.test(src) };
+  if (/^-?\d+(\.\d+)?$/.test(src)) return { literal: Number(src) };
+  const str = /^'(.*)'$/.exec(src);
+  if (str) return { literal: str[1] };
+  return void 0;
+}
+function addRelations(models, modelNames, constraints) {
+  const byName = new Map(models.map((m) => [m.name, m]));
+  for (const fk of constraints) {
+    if (fk.type !== "FOREIGN KEY" || !fk.references) continue;
+    const childModel = byName.get(modelNames.get(fk.table));
+    const parentModel = byName.get(modelNames.get(fk.references.table));
+    if (!childModel || !parentModel) continue;
+    const localFieldNames = fk.columns.map((c) => columnToField(childModel, c));
+    const refFieldNames = fk.references.columns.map(
+      (c) => columnToField(parentModel, c)
+    );
+    const childFieldName = uniqueFieldName(childModel, lowerFirst(parentModel.name));
+    childModel.fields.push({
+      name: childFieldName,
+      type: parentModel.name,
+      kind: "object",
+      isList: false,
+      isRequired: localFieldNames.every(
+        (n) => childModel.fields.find((f) => f.name === n)?.isRequired
+      ),
+      isId: false,
+      isUnique: false,
+      isUpdatedAt: false,
+      relation: {
+        fields: localFieldNames,
+        references: refFieldNames,
+        onDelete: mapRule(fk.deleteRule),
+        onUpdate: mapRule(fk.updateRule)
+      }
+    });
+    const backName = uniqueFieldName(
+      parentModel,
+      lowerFirst(pluralize(childModel.name))
+    );
+    parentModel.fields.push({
+      name: backName,
+      type: childModel.name,
+      kind: "object",
+      isList: true,
+      isRequired: false,
+      isId: false,
+      isUnique: false,
+      isUpdatedAt: false
+    });
+  }
+}
+function columnToField(model, column) {
+  const f = model.fields.find((x) => (x.dbName ?? x.name) === column);
+  return f ? f.name : camelCase(column);
+}
+function uniqueFieldName(model, base) {
+  let name = base;
+  let i = 1;
+  while (model.fields.some((f) => f.name === name)) name = `${base}_${++i}`;
+  return name;
+}
+function mapRule(rule) {
+  switch ((rule ?? "").toUpperCase()) {
+    case "CASCADE":
+      return "Cascade";
+    case "SET NULL":
+      return "SetNull";
+    case "SET DEFAULT":
+      return "SetDefault";
+    case "NO ACTION":
+      return "NoAction";
+    case "RESTRICT":
+      return "Restrict";
+    default:
+      return void 0;
+  }
+}
+function buildNameMap(dbNames, transform = pascalCase) {
+  const map = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const dbName of uniq(dbNames)) {
+    let name = transform(dbName);
+    if (!name) name = dbName;
+    let candidate = name;
+    let i = 1;
+    while (used.has(candidate)) candidate = `${name}_${++i}`;
+    used.add(candidate);
+    map.set(dbName, candidate);
+  }
+  return map;
+}
+function groupBy(items, key) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const k = key(item);
+    const list = map.get(k) ?? [];
+    list.push(item);
+    map.set(k, list);
+  }
+  return map;
+}
+
+// src/generator/index.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+
+// src/generator/ts-types.ts
+var SCALAR_TS = {
+  String: "string",
+  Boolean: "boolean",
+  Int: "number",
+  BigInt: "bigint",
+  Float: "number",
+  Decimal: "number",
+  DateTime: "Date",
+  Bytes: "Buffer",
+  Json: "JsonValue"
+};
+function baseTsType(field, schema) {
+  if (field.kind === "enum") return field.type;
+  if (field.kind === "object") return field.type;
+  return SCALAR_TS[field.type] ?? "unknown";
+}
+
+// src/generator/index.ts
+var ClientGenerator = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  schema;
+  generate() {
+    const parts = [];
+    parts.push(this.header());
+    parts.push(this.enums());
+    parts.push(this.modelTypes());
+    parts.push(this.registry());
+    parts.push(PAYLOAD_RESOLVER);
+    parts.push(this.namespace());
+    parts.push(this.clientClass());
+    return parts.filter(Boolean).join("\n\n") + "\n";
+  }
+  // ---- header & shared ----------------------------------------------------
+  header() {
+    return `// AUTO-GENERATED by EmberORM. Do not edit by hand.
+/* eslint-disable */
+import { EmberClientBase } from "ember-orm/client";
+import type { ClientOptions } from "ember-orm/client";
+
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | { [key: string]: JsonValue }
+  | JsonValue[];
+
+export type SortOrder = "asc" | "desc";
+export type QueryMode = "default" | "insensitive";
+
+const schemaDocument = ${JSON.stringify(this.schema)} as unknown as ClientOptions["schema"];`;
+  }
+  enums() {
+    return this.schema.enums.map((e) => this.enumType(e)).join("\n\n");
+  }
+  enumType(node) {
+    const values = node.values.map((v) => `  ${v.name}: "${v.name}"`).join(",\n");
+    return `export const ${node.name} = {
+${values}
+} as const;
+export type ${node.name} = (typeof ${node.name})[keyof typeof ${node.name}];`;
+  }
+  modelTypes() {
+    return this.schema.models.map((m) => this.modelType(m)).join("\n\n");
+  }
+  modelType(model) {
+    const scalars = scalarFields(model).map((f) => `  ${f.name}: ${this.scalarType(f)};`).join("\n");
+    const lines = [];
+    lines.push(`export type ${model.name} = {
+${scalars}
+};`);
+    lines.push(`export type ${model.name}GetPayload<A> = $Payload<"${model.name}", A>;`);
+    lines.push(this.fluentType(model));
+    return lines.join("\n");
+  }
+  /**
+   * Fluent-API return type for single-record reads: a Promise of the payload
+   * that also exposes a method per relation (to-many -> array; to-one ->
+   * chainable fluent).
+   */
+  fluentType(model) {
+    const n = model.name;
+    const methods = relationFields(model).map((f) => {
+      if (f.isList) {
+        return `  ${f.name}<S extends Prisma.${f.type}FindManyArgs = {}>(args?: S): Promise<${f.type}GetPayload<S>[]>;`;
+      }
+      return `  ${f.name}<S extends Prisma.${f.type}FindFirstArgs = {}>(args?: S): ${f.type}Fluent<S, null>;`;
+    });
+    return `export type ${n}Fluent<A, Null = null> = Promise<${n}GetPayload<A> | Null> & {
+${methods.join("\n")}
+};`;
+  }
+  /**
+   * Type-level registry powering recursive payload resolution: a model-name
+   * union, a scalar-payload map, and a relation map carrying each relation's
+   * target model, list-ness and nullability.
+   */
+  registry() {
+    const names = this.schema.models.map((m) => `"${m.name}"`).join(" | ");
+    const scalarEntries = this.schema.models.map((m) => `  ${m.name}: ${m.name};`).join("\n");
+    const relationEntries = this.schema.models.map((m) => {
+      const rels = relationFields(m).map((f) => {
+        const nullable = !f.isList && !f.isRequired ? "; isNullable: true" : "";
+        return `    ${f.name}: { model: "${f.type}"; isList: ${f.isList}${nullable} }`;
+      }).join(";\n");
+      return `  ${m.name}: {${rels ? `
+${rels}
+  ` : ""}};`;
+    }).join("\n");
+    return `export type $ModelName = ${names || "never"};
+
+export interface $ScalarPayload {
+${scalarEntries}
+}
+
+export interface $RelationMap {
+${relationEntries}
+}`;
+  }
+  scalarType(field) {
+    const base = baseTsType(field, this.schema);
+    if (field.isList) return `${base}[]`;
+    return field.isRequired ? base : `${base} | null`;
+  }
+  // ---- input types (Prisma namespace) -------------------------------------
+  namespace() {
+    const blocks = [SHARED_FILTERS];
+    for (const model of this.schema.models) {
+      blocks.push(this.whereInput(model));
+      blocks.push(this.orderByInput(model));
+      blocks.push(this.selectInclude(model));
+      blocks.push(this.dataInputs(model));
+      blocks.push(this.argsTypes(model));
+      blocks.push(this.delegateInterface(model));
+    }
+    return `export namespace Prisma {
+${indentBlock(blocks.join("\n\n"))}
+}`;
+  }
+  whereInput(model) {
+    const fields = [];
+    for (const f of model.fields) {
+      if (f.kind === "object") {
+        fields.push(`  ${f.name}?: ${this.relationFilter(f)};`);
+      } else {
+        fields.push(`  ${f.name}?: ${this.fieldFilter(f)};`);
+      }
+    }
+    return `export type ${model.name}WhereInput = {
+  AND?: ${model.name}WhereInput | ${model.name}WhereInput[];
+  OR?: ${model.name}WhereInput[];
+  NOT?: ${model.name}WhereInput | ${model.name}WhereInput[];
+${fields.join("\n")}
+};
+
+export type ${model.name}WhereUniqueInput = ${this.whereUnique(model)};`;
+  }
+  whereUnique(model) {
+    const uniques = /* @__PURE__ */ new Set();
+    for (const f of model.fields) if (f.isId || f.isUnique) uniques.add(f.name);
+    for (const f of model.primaryKey) uniques.add(f);
+    const parts = [...uniques].map((name) => {
+      const field = model.fields.find((x) => x.name === name);
+      return `{ ${name}: ${baseTsType(field, this.schema)} }`;
+    });
+    const base = `Partial<${model.name}WhereInput>`;
+    return parts.length ? `(${parts.join(" | ")}) & ${base}` : base;
+  }
+  fieldFilter(field) {
+    const base = baseTsType(field, this.schema);
+    const filterName = FILTER_FOR_SCALAR[field.type] ?? null;
+    if (field.kind === "enum") {
+      return `${base} | { equals?: ${base}; in?: ${base}[]; notIn?: ${base}[]; not?: ${base} }`;
+    }
+    if (filterName) return `${base} | ${filterName}`;
+    return `${base}`;
+  }
+  relationFilter(field) {
+    if (field.isList) {
+      return `{ some?: ${field.type}WhereInput; every?: ${field.type}WhereInput; none?: ${field.type}WhereInput }`;
+    }
+    return `${field.type}WhereInput | { is?: ${field.type}WhereInput | null; isNot?: ${field.type}WhereInput | null } | null`;
+  }
+  orderByInput(model) {
+    const fields = scalarFields(model).map((f) => `  ${f.name}?: SortOrder;`).join("\n");
+    return `export type ${model.name}OrderByInput = {
+${fields}
+};`;
+  }
+  selectInclude(model) {
+    const scalarSel = scalarFields(model).map((f) => `  ${f.name}?: boolean;`).join("\n");
+    const relSel = relationFields(model).map((f) => `  ${f.name}?: boolean | ${f.type}FindManyArgs;`).join("\n");
+    const include = relationFields(model).map((f) => `  ${f.name}?: boolean | ${f.type}FindManyArgs;`).join("\n");
+    const listRelations = relationFields(model).filter((f) => f.isList);
+    const countLine = listRelations.length ? `
+  _count?: boolean | { select?: { ${listRelations.map((f) => `${f.name}?: boolean`).join("; ")} } };` : "";
+    return `export type ${model.name}Select = {
+${scalarSel}${relSel ? "\n" + relSel : ""}${countLine}
+};
+
+export type ${model.name}Include = {
+${include || "  [k: string]: never;"}${countLine}
+};`;
+  }
+  dataInputs(model) {
+    const foreignKeys2 = /* @__PURE__ */ new Set();
+    for (const rel of relationFields(model)) {
+      for (const fk of rel.relation?.fields ?? []) foreignKeys2.add(fk);
+    }
+    const createScalars = scalarFields(model).filter((f) => !isGeneratedOnCreate(f)).map((f) => {
+      const optional = isOptionalOnCreate(f) || foreignKeys2.has(f.name) ? "?" : "";
+      return `  ${f.name}${optional}: ${this.inputScalarType(f)};`;
+    });
+    const createRelations = relationFields(model).map(
+      (f) => `  ${f.name}?: ${this.nestedCreate(f)};`
+    );
+    const updateScalars = scalarFields(model).map(
+      (f) => `  ${f.name}?: ${this.updateScalarType(f)};`
+    );
+    const updateRelations = relationFields(model).map(
+      (f) => `  ${f.name}?: ${this.nestedUpdate(f)};`
+    );
+    return `export type ${model.name}CreateInput = {
+${[...createScalars, ...createRelations].join("\n")}
+};
+
+export type ${model.name}UpdateInput = {
+${[...updateScalars, ...updateRelations].join("\n")}
+};`;
+  }
+  inputScalarType(field) {
+    const base = baseTsType(field, this.schema);
+    if (field.isList) return `${base}[]`;
+    return field.isRequired ? base : `${base} | null`;
+  }
+  /**
+   * Update value for a scalar field: a bare value, `{ set }`, and — for numeric
+   * fields — the atomic operators increment/decrement/multiply/divide.
+   */
+  updateScalarType(field) {
+    const value = this.inputScalarType(field);
+    if (field.isList) return value;
+    const base = baseTsType(field, this.schema);
+    if (NUMERIC_SCALARS.has(field.type)) {
+      const nullable = field.isRequired ? "" : " | null";
+      return `${value} | { set?: ${base}${nullable}; increment?: ${base}; decrement?: ${base}; multiply?: ${base}; divide?: ${base} }`;
+    }
+    return `${value} | { set?: ${value} }`;
+  }
+  nestedCreate(field) {
+    const t = field.type;
+    if (field.isList) {
+      return `{ create?: ${t}CreateInput | ${t}CreateInput[]; connect?: ${t}WhereUniqueInput | ${t}WhereUniqueInput[]; connectOrCreate?: { where: ${t}WhereUniqueInput; create: ${t}CreateInput } | { where: ${t}WhereUniqueInput; create: ${t}CreateInput }[] }`;
+    }
+    return `{ create?: ${t}CreateInput; connect?: ${t}WhereUniqueInput; connectOrCreate?: { where: ${t}WhereUniqueInput; create: ${t}CreateInput } }`;
+  }
+  nestedUpdate(field) {
+    const t = field.type;
+    if (field.isList) {
+      return `{ create?: ${t}CreateInput | ${t}CreateInput[]; connect?: ${t}WhereUniqueInput | ${t}WhereUniqueInput[]; disconnect?: ${t}WhereUniqueInput | ${t}WhereUniqueInput[]; set?: ${t}WhereUniqueInput | ${t}WhereUniqueInput[]; delete?: ${t}WhereUniqueInput | ${t}WhereUniqueInput[] }`;
+    }
+    return `{ create?: ${t}CreateInput; connect?: ${t}WhereUniqueInput; disconnect?: boolean }`;
+  }
+  argsTypes(model) {
+    const n = model.name;
+    return `export type ${n}Omit = Partial<Record<keyof ${n}, boolean>>;
+
+export type ${n}FindManyArgs = {
+  where?: ${n}WhereInput;
+  orderBy?: ${n}OrderByInput | ${n}OrderByInput[];
+  select?: ${n}Select;
+  include?: ${n}Include;
+  omit?: ${n}Omit;
+  take?: number;
+  skip?: number;
+  cursor?: ${n}WhereUniqueInput;
+  distinct?: (keyof ${n})[];
+};
+
+export type ${n}FindFirstArgs = ${n}FindManyArgs;
+
+export type ${n}FindUniqueArgs = {
+  where: ${n}WhereUniqueInput;
+  select?: ${n}Select;
+  include?: ${n}Include;
+  omit?: ${n}Omit;
+};
+
+export type ${n}CreateArgs = {
+  data: ${n}CreateInput;
+  select?: ${n}Select;
+  include?: ${n}Include;
+  omit?: ${n}Omit;
+};
+
+export type ${n}CreateManyArgs = { data: ${n}CreateInput[]; skipDuplicates?: boolean };
+
+export type ${n}CreateManyAndReturnArgs = {
+  data: ${n}CreateInput[];
+  select?: ${n}Select;
+  omit?: ${n}Omit;
+  skipDuplicates?: boolean;
+};
+
+export type ${n}UpdateArgs = {
+  where: ${n}WhereUniqueInput;
+  data: ${n}UpdateInput;
+  select?: ${n}Select;
+  include?: ${n}Include;
+  omit?: ${n}Omit;
+};
+
+export type ${n}UpdateManyArgs = { where?: ${n}WhereInput; data: ${n}UpdateInput };
+
+export type ${n}UpsertArgs = {
+  where: ${n}WhereUniqueInput;
+  create: ${n}CreateInput;
+  update: ${n}UpdateInput;
+  select?: ${n}Select;
+  include?: ${n}Include;
+  omit?: ${n}Omit;
+};
+
+export type ${n}DeleteArgs = { where: ${n}WhereUniqueInput; select?: ${n}Select; include?: ${n}Include };
+export type ${n}DeleteManyArgs = { where?: ${n}WhereInput };
+
+export type ${n}CountArgs = { where?: ${n}WhereInput; take?: number; skip?: number };
+
+export type ${n}AggregateArgs = {
+  where?: ${n}WhereInput;
+  _count?: true | Partial<Record<keyof ${n}, boolean>>;
+  _avg?: Partial<Record<keyof ${n}, boolean>>;
+  _sum?: Partial<Record<keyof ${n}, boolean>>;
+  _min?: Partial<Record<keyof ${n}, boolean>>;
+  _max?: Partial<Record<keyof ${n}, boolean>>;
+};
+
+export type ${n}GroupByArgs = ${n}AggregateArgs & {
+  by: (keyof ${n})[];
+  having?: ${n}WhereInput;
+  orderBy?: ${n}OrderByInput | ${n}OrderByInput[];
+};`;
+  }
+  delegateInterface(model) {
+    const n = model.name;
+    return `export interface ${n}Delegate {
+  findMany<A extends ${n}FindManyArgs>(args?: A): Promise<${n}GetPayload<A>[]>;
+  findFirst<A extends ${n}FindFirstArgs>(args?: A): ${n}Fluent<A, null>;
+  findFirstOrThrow<A extends ${n}FindFirstArgs>(args?: A): ${n}Fluent<A, never>;
+  findUnique<A extends ${n}FindUniqueArgs>(args: A): ${n}Fluent<A, null>;
+  findUniqueOrThrow<A extends ${n}FindUniqueArgs>(args: A): ${n}Fluent<A, never>;
+  create<A extends ${n}CreateArgs>(args: A): Promise<${n}GetPayload<A>>;
+  createMany(args: ${n}CreateManyArgs): Promise<{ count: number }>;
+  createManyAndReturn<A extends ${n}CreateManyAndReturnArgs>(args: A): Promise<${n}GetPayload<A>[]>;
+  update<A extends ${n}UpdateArgs>(args: A): Promise<${n}GetPayload<A>>;
+  updateMany(args: ${n}UpdateManyArgs): Promise<{ count: number }>;
+  upsert<A extends ${n}UpsertArgs>(args: A): Promise<${n}GetPayload<A>>;
+  delete<A extends ${n}DeleteArgs>(args: A): Promise<${n}GetPayload<A>>;
+  deleteMany(args?: ${n}DeleteManyArgs): Promise<{ count: number }>;
+  count(args?: ${n}CountArgs): Promise<number>;
+  aggregate(args?: ${n}AggregateArgs): Promise<Record<string, any>>;
+  groupBy(args: ${n}GroupByArgs): Promise<Record<string, any>[]>;
+}`;
+  }
+  // ---- client class -------------------------------------------------------
+  clientClass() {
+    const delegates = this.schema.models.map((m) => `  declare readonly ${lowerFirst(m.name)}: Prisma.${m.name}Delegate;`).join("\n");
+    return `export type EmberClientOptions = {
+  datasourceUrl?: string;
+  datasource?: ClientOptions["datasource"];
+  log?: ClientOptions["log"];
+};
+
+export class EmberClient extends EmberClientBase {
+  constructor(options: EmberClientOptions = {}) {
+    super({ schema: schemaDocument, ...options });
+  }
+
+${delegates}
+}`;
+  }
+};
+function generateClientSource(schema) {
+  return new ClientGenerator(schema).generate();
+}
+function writeClient(schema, outDir) {
+  const source = generateClientSource(schema);
+  const file = resolve2(outDir, "index.ts");
+  mkdirSync(dirname2(file), { recursive: true });
+  writeFileSync(file, source, "utf8");
+  return file;
+}
+var PAYLOAD_RESOLVER = `type $Scalar<M extends $ModelName> = $ScalarPayload[M];
+type $Relations<M extends $ModelName> = M extends keyof $RelationMap
+  ? $RelationMap[M]
+  : {};
+
+// A relation sub-arg may be \`true\` (full payload) or a nested args object.
+type $NormalizeArgs<Sub> = Sub extends object ? Sub : {};
+
+type $RelationResult<Info, Sub> = Info extends {
+  model: infer RM extends $ModelName;
+  isList: infer L;
+}
+  ? L extends true
+    ? $Payload<RM, $NormalizeArgs<Sub>>[]
+    : Info extends { isNullable: true }
+      ? $Payload<RM, $NormalizeArgs<Sub>> | null
+      : $Payload<RM, $NormalizeArgs<Sub>>
+  : never;
+
+// To-many relation keys of a model (eligible for _count).
+type $ListRelations<M extends $ModelName> = {
+  [K in keyof $Relations<M>]: $Relations<M>[K] extends { isList: true }
+    ? K
+    : never;
+}[keyof $Relations<M>];
+
+type $CountResult<M extends $ModelName, C> = C extends { select: infer SC }
+  ? { [K in keyof SC & $ListRelations<M>]: number }
+  : { [K in $ListRelations<M> & string]: number };
+
+type $CountPart<M extends $ModelName, A> = A extends { _count: infer C }
+  ? { _count: $CountResult<M, C> }
+  : {};
+
+type $SelectResult<M extends $ModelName, S> = {
+  [K in keyof S & keyof $Scalar<M>]: $Scalar<M>[K];
+} & {
+  [K in keyof S & keyof $Relations<M>]: $RelationResult<$Relations<M>[K], S[K]>;
+} & $CountPart<M, S>;
+
+type $IncludeResult<M extends $ModelName, I> = {
+  [K in keyof I & keyof $Relations<M>]: $RelationResult<$Relations<M>[K], I[K]>;
+} & $CountPart<M, I>;
+
+export type $Payload<M extends $ModelName, A> = A extends { select: infer S }
+  ? $SelectResult<M, S>
+  : A extends { include: infer I }
+    ? $Scalar<M> & $IncludeResult<M, I>
+    : $Scalar<M>;`;
+var NUMERIC_SCALARS = /* @__PURE__ */ new Set(["Int", "BigInt", "Float", "Decimal"]);
+var FILTER_FOR_SCALAR = {
+  String: "StringFilter",
+  Int: "IntFilter",
+  BigInt: "BigIntFilter",
+  Float: "FloatFilter",
+  Decimal: "FloatFilter",
+  Boolean: "BoolFilter",
+  DateTime: "DateTimeFilter",
+  Bytes: "BytesFilter",
+  Json: "JsonFilter"
+};
+var SHARED_FILTERS = `export type StringFilter = {
+  equals?: string;
+  not?: string | StringFilter;
+  in?: string[];
+  notIn?: string[];
+  lt?: string;
+  lte?: string;
+  gt?: string;
+  gte?: string;
+  contains?: string;
+  startsWith?: string;
+  endsWith?: string;
+  mode?: QueryMode;
+};
+
+export type IntFilter = {
+  equals?: number;
+  not?: number | IntFilter;
+  in?: number[];
+  notIn?: number[];
+  lt?: number;
+  lte?: number;
+  gt?: number;
+  gte?: number;
+};
+
+export type FloatFilter = IntFilter;
+export type BigIntFilter = {
+  equals?: bigint;
+  not?: bigint | BigIntFilter;
+  in?: bigint[];
+  notIn?: bigint[];
+  lt?: bigint;
+  lte?: bigint;
+  gt?: bigint;
+  gte?: bigint;
+};
+
+export type BoolFilter = { equals?: boolean; not?: boolean };
+
+export type DateTimeFilter = {
+  equals?: Date;
+  not?: Date | DateTimeFilter;
+  in?: Date[];
+  notIn?: Date[];
+  lt?: Date;
+  lte?: Date;
+  gt?: Date;
+  gte?: Date;
+};
+
+export type BytesFilter = { equals?: Buffer; not?: Buffer };
+
+// Firebird has no JSON SQL functions: filters operate on the serialized text.
+// 'path' is accepted by the type but rejected at runtime on Firebird.
+export type JsonFilter = {
+  equals?: JsonValue;
+  not?: JsonValue;
+  string_contains?: string;
+  string_starts_with?: string;
+  string_ends_with?: string;
+  path?: string[];
+};`;
+function isGeneratedOnCreate(field) {
+  return field.default?.function?.name === "autoincrement";
+}
+function isOptionalOnCreate(field) {
+  return !field.isRequired || !!field.default || field.isUpdatedAt || field.isList;
+}
+function indentBlock(text) {
+  return text.split("\n").map((l) => l ? "  " + l : l).join("\n");
+}
+
+// src/migrate/index.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/migrate/diff.ts
+function diffSchemas(desired, current) {
+  const currentByTable = new Map(
+    current.models.map((m) => [modelTable(m), m])
+  );
+  const desiredTables = new Set(desired.models.map((m) => modelTable(m)));
+  const createdModels = [];
+  const modelChanges = [];
+  for (const model of desired.models) {
+    const table = modelTable(model);
+    const currentModel = currentByTable.get(table);
+    if (!currentModel) {
+      createdModels.push(model);
+      continue;
+    }
+    const change = diffModel(desired, model, currentModel, table);
+    if (hasModelChanges(change)) modelChanges.push(change);
+  }
+  const droppedTables = current.models.map((m) => modelTable(m)).filter((t) => !desiredTables.has(t));
+  return { createdModels, droppedTables, modelChanges };
+}
+function diffModel(desired, model, current, table) {
+  const desiredCols = new Map(
+    scalarFields(model).map((f) => [fieldColumn(f), f])
+  );
+  const currentCols = new Map(
+    scalarFields(current).map((f) => [fieldColumn(f), f])
+  );
+  const addedColumns = [];
+  const changedColumns = [];
+  for (const [col, field] of desiredCols) {
+    const existing = currentCols.get(col);
+    if (!existing) {
+      addedColumns.push(field);
+      continue;
+    }
+    const typeChanged = !sameColumnType(field, existing);
+    const nullabilityChanged = field.isRequired !== existing.isRequired;
+    if (typeChanged || nullabilityChanged) {
+      changedColumns.push({ field, table, typeChanged, nullabilityChanged });
+    }
+  }
+  const droppedColumns = [...currentCols.keys()].filter(
+    (c) => !desiredCols.has(c)
+  );
+  const currentUniqueSets = uniqueColumnSets(current).map(setKey);
+  const addedUniques = uniqueColumnSets(model).filter((cols) => !currentUniqueSets.includes(setKey(cols))).map((cols) => ({ name: constraintName("UQ", table, cols), columns: cols }));
+  const currentFkSets = foreignKeys(desired, current).map(fkKey);
+  const addedForeignKeys = foreignKeys(desired, model).filter((fk) => !currentFkSets.includes(fkKey(fk))).map((fk) => ({ ...fk, name: constraintName("FK", table, fk.columns) }));
+  return {
+    model,
+    table,
+    addedColumns,
+    droppedColumns,
+    changedColumns,
+    addedUniques,
+    addedForeignKeys
+  };
+}
+function hasModelChanges(c) {
+  return c.addedColumns.length > 0 || c.droppedColumns.length > 0 || c.changedColumns.length > 0 || c.addedUniques.length > 0 || c.addedForeignKeys.length > 0;
+}
+function uniqueColumnSets(model) {
+  const sets = [];
+  for (const f of scalarFields(model)) {
+    if (f.isUnique) sets.push([fieldColumn(f)]);
+  }
+  for (const u of model.uniqueIndexes) {
+    sets.push(u.fields.map((name) => columnFor(model, name)));
+  }
+  return sets;
+}
+function indexSpecs(model) {
+  return model.indexes.map((i) => ({
+    name: i.name ?? constraintName("IDX", modelTable(model), i.fields.map((n) => columnFor(model, n))),
+    columns: i.fields.map((name) => columnFor(model, name)),
+    unique: i.unique
+  }));
+}
+function foreignKeys(schema, model) {
+  const out = [];
+  for (const f of relationFields(model)) {
+    const rel = f.relation;
+    if (!rel?.fields?.length) continue;
+    const refModel = schema.models.find((m) => m.name === f.type);
+    if (!refModel) continue;
+    out.push({
+      columns: rel.fields.map((name) => columnFor(model, name)),
+      refTable: modelTable(refModel),
+      refColumns: (rel.references ?? []).map((name) => columnFor(refModel, name)),
+      onDelete: rel.onDelete,
+      onUpdate: rel.onUpdate
+    });
+  }
+  return out;
+}
+function columnFor(model, fieldName) {
+  const f = model.fields.find((x) => x.name === fieldName);
+  return f ? fieldColumn(f) : fieldName.toUpperCase();
+}
+function sameColumnType(a, b) {
+  if (a.type !== b.type) return false;
+  return sameNative(a.nativeType, b.nativeType);
+}
+function sameNative(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return true;
+  return a.name === b.name && a.args.join(",") === b.args.join(",");
+}
+function setKey(cols) {
+  return [...cols].sort().join(",");
+}
+function fkKey(fk) {
+  return `${setKey(fk.columns)}->${fk.refTable}(${setKey(fk.refColumns)})`;
+}
+function constraintName(prefix, table, columns) {
+  const base = `${prefix}_${table}_${columns.join("_")}`.replace(/[^A-Za-z0-9_]/g, "_");
+  if (base.length <= 31) return base;
+  let hash = 0;
+  for (let i = 0; i < base.length; i++) hash = hash * 31 + base.charCodeAt(i) | 0;
+  const suffix = Math.abs(hash).toString(36).slice(0, 6);
+  return `${base.slice(0, 24)}_${suffix}`;
+}
+
+// src/migrate/ddl.ts
+var FirebirdDdl = class {
+  constructor(d) {
+    this.d = d;
+  }
+  d;
+  // ---- column types -------------------------------------------------------
+  /** Firebird column type for a field, honoring its `@db.*` native type. */
+  columnType(field) {
+    const native = field.nativeType;
+    if (native) {
+      const args = native.args.length ? `(${native.args.join(", ")})` : "";
+      switch (native.name) {
+        case "VarChar":
+          return `VARCHAR${args || "(255)"}`;
+        case "Char":
+          return `CHAR${args || "(1)"}`;
+        case "Text":
+          return "BLOB SUB_TYPE TEXT";
+        case "SmallInt":
+          return "SMALLINT";
+        case "Integer":
+          return "INTEGER";
+        case "BigInt":
+          return "BIGINT";
+        case "Float":
+          return "FLOAT";
+        case "DoublePrecision":
+          return "DOUBLE PRECISION";
+        case "Decimal":
+          return `DECIMAL${args || "(18, 4)"}`;
+        case "Boolean":
+          return this.d.booleanColumnType();
+        case "Date":
+          return "DATE";
+        case "Time":
+          return "TIME";
+        case "Timestamp":
+          return "TIMESTAMP";
+        case "Blob":
+          return "BLOB SUB_TYPE BINARY";
+      }
+    }
+    if (field.type === "Boolean") return this.d.booleanColumnType();
+    return DEFAULT_DDL_TYPE[field.type] ?? "VARCHAR(255)";
+  }
+  /** `"COL" <type> [GENERATED ...] [DEFAULT ...] [NOT NULL]`. */
+  columnDefinition(field) {
+    const parts = [this.d.quoteId(fieldColumn(field)), this.columnType(field)];
+    if (isIdentity(field) && this.d.supportsIdentity) {
+      parts.push("GENERATED BY DEFAULT AS IDENTITY");
+    } else if (!isIdentity(field)) {
+      const def = defaultClause(field.default);
+      if (def) parts.push(def);
+    }
+    if (field.isRequired) parts.push("NOT NULL");
+    return parts.join(" ");
+  }
+  /**
+   * On Firebird 2.1/2.5 (no IDENTITY), emulate autoincrement with a SEQUENCE
+   * and a BEFORE INSERT trigger. Returns the extra DDL objects to create after
+   * the table; an empty array when IDENTITY is supported.
+   */
+  autoIncrementObjects(model) {
+    if (this.d.supportsIdentity) return [];
+    const table = modelTable(model);
+    const out = [];
+    for (const field of scalarFields(model)) {
+      if (isIdentity(field)) {
+        out.push(...this.autoIncrementForColumn(table, fieldColumn(field)));
+      }
+    }
+    return out;
+  }
+  autoIncrementForColumn(table, column) {
+    if (this.d.supportsIdentity) return [];
+    const seq = capName(`GEN_${table}_${column}`);
+    const trig = capName(`${table}_BI_${column}`);
+    const qTable = this.d.quoteId(table);
+    const qCol = this.d.quoteId(column);
+    const qSeq = this.d.quoteId(seq);
+    return [
+      `CREATE SEQUENCE ${qSeq}`,
+      `CREATE TRIGGER ${this.d.quoteId(trig)} FOR ${qTable} ACTIVE BEFORE INSERT POSITION 0 AS
+BEGIN
+  IF (NEW.${qCol} IS NULL) THEN NEW.${qCol} = GEN_ID(${qSeq}, 1);
+END`
+    ];
+  }
+  // ---- table-level --------------------------------------------------------
+  createTable(model) {
+    const cols = scalarFields(model).map((f) => "  " + this.columnDefinition(f));
+    const pk = idFields(model);
+    const lines = [...cols];
+    if (pk.length > 0) {
+      lines.push(
+        `  PRIMARY KEY (${pk.map((f) => this.d.quoteId(fieldColumn(f))).join(", ")})`
+      );
+    }
+    return `CREATE TABLE ${this.d.quoteId(modelTable(model))} (
+${lines.join(",\n")}
+)`;
+  }
+  dropTable(table) {
+    return `DROP TABLE ${this.d.quoteId(table)}`;
+  }
+  addColumn(table, field) {
+    return `ALTER TABLE ${this.d.quoteId(table)} ADD ${this.columnDefinition(field)}`;
+  }
+  dropColumn(table, column) {
+    return `ALTER TABLE ${this.d.quoteId(table)} DROP ${this.d.quoteId(column)}`;
+  }
+  /** Change a column's data type (Firebird: ALTER COLUMN ... TYPE ...). */
+  alterColumnType(table, field) {
+    return `ALTER TABLE ${this.d.quoteId(table)} ALTER COLUMN ${this.d.quoteId(
+      fieldColumn(field)
+    )} TYPE ${this.columnType(field)}`;
+  }
+  setNotNull(table, column, notNull) {
+    const action = notNull ? "SET NOT NULL" : "DROP NOT NULL";
+    return `ALTER TABLE ${this.d.quoteId(table)} ALTER COLUMN ${this.d.quoteId(
+      column
+    )} ${action}`;
+  }
+  // ---- constraints & indexes ---------------------------------------------
+  addUnique(table, name, columns) {
+    return `ALTER TABLE ${this.d.quoteId(table)} ADD CONSTRAINT ${this.d.quoteId(
+      name
+    )} UNIQUE (${columns.map((c) => this.d.quoteId(c)).join(", ")})`;
+  }
+  dropConstraint(table, name) {
+    return `ALTER TABLE ${this.d.quoteId(table)} DROP CONSTRAINT ${this.d.quoteId(name)}`;
+  }
+  addForeignKey(table, name, columns, refTable, refColumns, onDelete, onUpdate) {
+    let sql = `ALTER TABLE ${this.d.quoteId(table)} ADD CONSTRAINT ${this.d.quoteId(
+      name
+    )} FOREIGN KEY (${columns.map((c) => this.d.quoteId(c)).join(", ")}) REFERENCES ${this.d.quoteId(
+      refTable
+    )} (${refColumns.map((c) => this.d.quoteId(c)).join(", ")})`;
+    if (onUpdate) sql += ` ON UPDATE ${referentialSql(onUpdate)}`;
+    if (onDelete) sql += ` ON DELETE ${referentialSql(onDelete)}`;
+    return sql;
+  }
+  createIndex(table, name, columns, unique) {
+    return `CREATE ${unique ? "UNIQUE " : ""}INDEX ${this.d.quoteId(name)} ON ${this.d.quoteId(
+      table
+    )} (${columns.map((c) => this.d.quoteId(c)).join(", ")})`;
+  }
+  dropIndex(name) {
+    return `DROP INDEX ${this.d.quoteId(name)}`;
+  }
+};
+var DEFAULT_DDL_TYPE = {
+  String: "VARCHAR(255)",
+  Boolean: "BOOLEAN",
+  Int: "INTEGER",
+  BigInt: "BIGINT",
+  Float: "DOUBLE PRECISION",
+  Decimal: "DECIMAL(18, 4)",
+  DateTime: "TIMESTAMP",
+  Bytes: "BLOB SUB_TYPE BINARY",
+  Json: "BLOB SUB_TYPE TEXT"
+};
+function isIdentity(field) {
+  return field.default?.function?.name === "autoincrement";
+}
+function capName(name) {
+  const safe = name.replace(/[^A-Za-z0-9_]/g, "_");
+  if (safe.length <= 31) return safe;
+  let hash = 0;
+  for (let i = 0; i < safe.length; i++) hash = hash * 31 + safe.charCodeAt(i) | 0;
+  return `${safe.slice(0, 24)}_${Math.abs(hash).toString(36).slice(0, 6)}`;
+}
+function defaultClause(def) {
+  if (!def) return null;
+  if (def.function) {
+    switch (def.function.name) {
+      case "now":
+        return "DEFAULT CURRENT_TIMESTAMP";
+      case "uuid":
+      case "cuid":
+        return null;
+      // generated app-side
+      default:
+        return null;
+    }
+  }
+  if (def.literal === void 0) return null;
+  if (typeof def.literal === "boolean") {
+    return `DEFAULT ${def.literal ? "TRUE" : "FALSE"}`;
+  }
+  if (typeof def.literal === "number") return `DEFAULT ${def.literal}`;
+  return `DEFAULT '${String(def.literal).replace(/'/g, "''")}'`;
+}
+function referentialSql(action) {
+  switch (action) {
+    case "Cascade":
+      return "CASCADE";
+    case "SetNull":
+      return "SET NULL";
+    case "SetDefault":
+      return "SET DEFAULT";
+    case "NoAction":
+      return "NO ACTION";
+    case "Restrict":
+      return "NO ACTION";
+    // Firebird has no RESTRICT; NO ACTION is closest
+    default:
+      return "NO ACTION";
+  }
+}
+
+// src/migrate/planner.ts
+function planMigration(diff, desired, dialect) {
+  const ddl = new FirebirdDdl(dialect);
+  const drops = [];
+  const creates = [];
+  const alters = [];
+  const constraints = [];
+  const indexes = [];
+  const foreignKeyStmts = [];
+  for (const change of diff.modelChanges) {
+    for (const col of change.droppedColumns) {
+      drops.push(ddl.dropColumn(change.table, col));
+    }
+  }
+  for (const table of diff.droppedTables) {
+    drops.push(ddl.dropTable(table));
+  }
+  for (const model of diff.createdModels) {
+    const table = modelTable(model);
+    creates.push(ddl.createTable(model));
+    creates.push(...ddl.autoIncrementObjects(model));
+    for (const cols of uniqueColumnSets(model)) {
+      if (cols.length === 1) continue;
+      constraints.push(
+        ddl.addUnique(table, constraintName("UQ", table, cols), cols)
+      );
+    }
+    for (const idx of indexSpecs(model)) {
+      indexes.push(ddl.createIndex(table, idx.name, idx.columns, idx.unique));
+    }
+    for (const fk of foreignKeys(desired, model)) {
+      foreignKeyStmts.push(
+        ddl.addForeignKey(
+          table,
+          constraintName("FK", table, fk.columns),
+          fk.columns,
+          fk.refTable,
+          fk.refColumns,
+          fk.onDelete,
+          fk.onUpdate
+        )
+      );
+    }
+  }
+  for (const change of diff.modelChanges) {
+    for (const field of change.addedColumns) {
+      alters.push(ddl.addColumn(change.table, field));
+      if (isIdentity(field)) {
+        creates.push(
+          ...ddl.autoIncrementForColumn(change.table, fieldColumn(field))
+        );
+      }
+    }
+    for (const cc of change.changedColumns) {
+      if (cc.typeChanged) alters.push(ddl.alterColumnType(cc.table, cc.field));
+      if (cc.nullabilityChanged) {
+        alters.push(
+          ddl.setNotNull(cc.table, columnName(cc), cc.field.isRequired)
+        );
+      }
+    }
+    for (const uq of change.addedUniques) {
+      if (uq.columns.length === 1) {
+        constraints.push(ddl.addUnique(change.table, uq.name, uq.columns));
+      } else {
+        constraints.push(ddl.addUnique(change.table, uq.name, uq.columns));
+      }
+    }
+    for (const fk of change.addedForeignKeys) {
+      foreignKeyStmts.push(
+        ddl.addForeignKey(
+          change.table,
+          fk.name,
+          fk.columns,
+          fk.refTable,
+          fk.refColumns,
+          fk.onDelete,
+          fk.onUpdate
+        )
+      );
+    }
+  }
+  return [
+    ...drops,
+    ...creates,
+    ...alters,
+    ...constraints,
+    ...indexes,
+    ...foreignKeyStmts
+  ];
+}
+var BREAKPOINT = "--> statement-breakpoint";
+function renderMigrationSql(statements) {
+  if (statements.length === 0) return "-- This migration is empty.\n";
+  return statements.join(`
+${BREAKPOINT}
+`) + "\n";
+}
+function splitStatements(sql) {
+  return sql.split(BREAKPOINT).map((s) => stripComments(s).trim().replace(/;\s*$/, "").trim()).filter((s) => s.length > 0);
+}
+function stripComments(sql) {
+  return sql.split("\n").filter((line) => !line.trim().startsWith("--")).join("\n");
+}
+function columnName(cc) {
+  return cc.field.dbName ?? cc.field.name.toUpperCase();
+}
+
+// src/migrate/history.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import { join } from "path";
+var HISTORY_TABLE = "_EMBER_MIGRATIONS";
+async function ensureHistoryTable(tx, dialect) {
+  const exists = await tx.query(
+    `SELECT COUNT(*) AS N FROM RDB$RELATIONS WHERE RDB$RELATION_NAME = ?`,
+    [HISTORY_TABLE]
+  );
+  if (Number(exists[0]?.N ?? 0) > 0) return;
+  const t = dialect.quoteId(HISTORY_TABLE);
+  await tx.query(
+    `CREATE TABLE ${t} (
+       ${dialect.quoteId("ID")} VARCHAR(128) NOT NULL PRIMARY KEY,
+       ${dialect.quoteId("CHECKSUM")} VARCHAR(64),
+       ${dialect.quoteId("STEPS")} INTEGER,
+       ${dialect.quoteId("APPLIED_AT")} TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+     )`
+  );
+}
+async function appliedMigrations(tx, dialect) {
+  const t = dialect.quoteId(HISTORY_TABLE);
+  const rows = await tx.query(
+    `SELECT ${dialect.quoteId("ID")} AS "id", ${dialect.quoteId("CHECKSUM")} AS "checksum", ${dialect.quoteId("STEPS")} AS "steps" FROM ${t} ORDER BY ${dialect.quoteId("ID")}`
+  );
+  return rows.map((r) => ({
+    id: String(r.id).trim(),
+    checksum: r.checksum == null ? "" : String(r.checksum).trim(),
+    steps: Number(r.steps ?? 0)
+  }));
+}
+async function recordMigration(tx, dialect, migration) {
+  const t = dialect.quoteId(HISTORY_TABLE);
+  await tx.query(
+    `INSERT INTO ${t} (${dialect.quoteId("ID")}, ${dialect.quoteId("CHECKSUM")}, ${dialect.quoteId("STEPS")}) VALUES (?, ?, ?)`,
+    [migration.id, migration.checksum, migration.steps]
+  );
+}
+function listLocalMigrations(migrationsDir) {
+  if (!existsSync2(migrationsDir)) return [];
+  return readdirSync(migrationsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort().map((id) => {
+    const dir = join(migrationsDir, id);
+    const file = join(dir, "migration.sql");
+    return {
+      id,
+      dir,
+      sql: existsSync2(file) ? readFileSync2(file, "utf8") : ""
+    };
+  }).filter((m) => m.sql.length > 0);
+}
+function checksum(sql) {
+  let h = 2166136261;
+  for (let i = 0; i < sql.length; i++) {
+    h ^= sql.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+
+// src/migrate/index.ts
+var Migrator = class {
+  constructor(driver, desired, migrationsDir, dialect) {
+    this.driver = driver;
+    this.desired = desired;
+    this.migrationsDir = migrationsDir;
+    this.dialect = dialect ?? new FirebirdDialect();
+  }
+  driver;
+  desired;
+  migrationsDir;
+  dialect;
+  /** Compute the diff between the desired schema and the live database. */
+  async diff() {
+    const current = await this.currentSchema();
+    return diffSchemas(this.desired, current);
+  }
+  /** Plan (but do not apply) the DDL needed to reach the desired schema. */
+  async plan() {
+    const diff = await this.diff();
+    return planMigration(diff, this.desired, this.dialect);
+  }
+  /**
+   * `migrate dev`: create a timestamped migration from the current diff, apply
+   * it, and record it in history.
+   */
+  async dev(name = "migration") {
+    const statements = await this.plan();
+    if (statements.length === 0) return { empty: true, statements: [] };
+    const id = `${timestamp()}_${slug(name)}`;
+    const dir = join2(this.migrationsDir, id);
+    const body = renderMigrationSql(statements);
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(join2(dir, "migration.sql"), body, "utf8");
+    await this.driver.transaction(async (tx) => {
+      await ensureHistoryTable(tx, this.dialect);
+      for (const stmt of statements) await tx.query(stmt);
+      await recordMigration(tx, this.dialect, {
+        id,
+        checksum: checksum(body),
+        steps: statements.length
+      });
+    });
+    return { empty: false, id, dir, statements };
+  }
+  /**
+   * `db push`: apply the diff directly to the database without writing a
+   * migration file (prototyping flow).
+   */
+  async push() {
+    const statements = await this.plan();
+    if (statements.length === 0) return { statements: [] };
+    await this.driver.transaction(async (tx) => {
+      for (const stmt of statements) await tx.query(stmt);
+    });
+    return { statements };
+  }
+  /** `migrate deploy`: apply every on-disk migration not yet recorded. */
+  async deploy() {
+    const local = listLocalMigrations(this.migrationsDir);
+    const applied = [];
+    const known = await this.driver.transaction(async (tx) => {
+      await ensureHistoryTable(tx, this.dialect);
+      return new Set((await appliedMigrations(tx, this.dialect)).map((m) => m.id));
+    });
+    for (const migration of local) {
+      if (known.has(migration.id)) continue;
+      const statements = splitStatements(migration.sql);
+      await this.driver.transaction(async (tx) => {
+        for (const stmt of statements) await tx.query(stmt);
+        await recordMigration(tx, this.dialect, {
+          id: migration.id,
+          checksum: checksum(migration.sql),
+          steps: statements.length
+        });
+      });
+      applied.push({ id: migration.id, steps: statements.length });
+    }
+    return { applied };
+  }
+  /** `migrate status`: list applied vs pending migrations. */
+  async status() {
+    const local = listLocalMigrations(this.migrationsDir).map((m) => m.id);
+    const applied = await this.driver.transaction(async (tx) => {
+      await ensureHistoryTable(tx, this.dialect);
+      return (await appliedMigrations(tx, this.dialect)).map((m) => m.id);
+    });
+    const appliedSet = new Set(applied);
+    return {
+      applied,
+      pending: local.filter((id) => !appliedSet.has(id))
+    };
+  }
+  async currentSchema() {
+    const introspector = new Introspector(this.driver);
+    const current = await introspector.introspect();
+    current.models = current.models.filter(
+      (m) => modelTable(m) !== HISTORY_TABLE
+    );
+    return current;
+  }
+};
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getUTCFullYear()}${p(d.getUTCMonth() + 1)}${p(d.getUTCDate())}${p(d.getUTCHours())}${p(d.getUTCMinutes())}${p(d.getUTCSeconds())}`;
+}
+function slug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "migration";
+}
+export {
+  ClientGenerator,
+  DatabaseError,
+  EmberClientBase,
+  EmberError,
+  FirebirdDdl,
+  FirebirdDialect,
+  FirebirdDriver,
+  Introspector,
+  Migrator,
+  QueryEngine,
+  QueryValidationError,
+  RecordNotFoundError,
+  SCALAR_TYPES,
+  SchemaParseError,
+  SchemaValidationError,
+  Sql,
+  UniqueConstraintError,
+  buildConnectionUrl,
+  createClient,
+  createDriver,
+  diffSchemas,
+  emptySchema,
+  fieldColumn,
+  findEnum,
+  findModel,
+  findSchemaPath,
+  generateClientSource,
+  idFields,
+  loadSchema,
+  modelTable,
+  parseAndValidate,
+  parseConnectionUrl,
+  parseSchema,
+  planMigration,
+  printSchema,
+  relationFields,
+  renderMigrationSql,
+  resolveDatasourceUrl,
+  scalarFields,
+  splitStatements,
+  validateSchema,
+  writeClient
+};
+//# sourceMappingURL=index.js.map