@mateusseiboth/ember-orm 0.1.0

package/dist/cli/bin.js

@@ -0,0 +1,3241 @@
+#!/usr/bin/env node
+
+// src/cli/bin.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { fileURLToPath } from "url";
+
+// 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 DatabaseError = class extends EmberError {
+  constructor(message, cause, sql) {
+    super(message);
+    this.cause = cause;
+    this.sql = sql;
+  }
+  cause;
+  sql;
+};
+
+// src/cli/commands.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+
+// src/schema/index.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+
+// 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/ast/index.ts
+var SCALAR_TYPES = [
+  "String",
+  "Boolean",
+  "Int",
+  "BigInt",
+  "Float",
+  "Decimal",
+  "DateTime",
+  "Bytes",
+  "Json"
+];
+function findModel(schema, name) {
+  return schema.models.find((m) => m.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/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 rel2 = field.relation;
+    const args = [];
+    if (rel2.name) args.push(`"${rel2.name}"`);
+    if (rel2.fields?.length) args.push(`fields: [${rel2.fields.join(", ")}]`);
+    if (rel2.references?.length)
+      args.push(`references: [${rel2.references.join(", ")}]`);
+    if (rel2.onDelete) args.push(`onDelete: ${rel2.onDelete}`);
+    if (rel2.onUpdate) args.push(`onUpdate: ${rel2.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 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/relations-complete.ts
+function completeRelations(doc) {
+  const original = [];
+  for (const model of doc.models) {
+    for (const field of model.fields) {
+      if (field.kind === "object") original.push({ model, field });
+    }
+  }
+  for (const { model, field } of original) {
+    const related = findModel(doc, field.type);
+    if (!related) continue;
+    if (hasPartner(related, model, field)) continue;
+    if (field.isList) {
+      addOwningSide(related, model, field);
+    } else if (field.relation?.fields?.length) {
+      addBackRelation(related, model, field);
+    } else {
+      upgradeBareToOne(doc, model, field);
+    }
+  }
+  return doc;
+}
+function hasPartner(related, model, field) {
+  return related.fields.some(
+    (f) => f !== field && f.kind === "object" && f.type === model.name && relationNamesMatch(f, field)
+  );
+}
+function relationNamesMatch(a, b) {
+  const an = a.relation?.name;
+  const bn = b.relation?.name;
+  if (an && bn) return an === bn;
+  if (!an && !bn) return true;
+  return false;
+}
+function addBackRelation(related, owner, owning) {
+  const fkFields = (owning.relation?.fields ?? []).map((n) => owner.fields.find((f) => f.name === n)).filter((f) => !!f);
+  const isOneToOne = fkFields.length > 0 && fkFields.every((f) => f.isUnique);
+  const baseName = isOneToOne ? camelCase(owner.name) : camelCase(pluralize(owner.name));
+  const name = uniqueFieldName(related, baseName);
+  related.fields.push({
+    name,
+    type: owner.name,
+    kind: "object",
+    isList: !isOneToOne,
+    isRequired: false,
+    isId: false,
+    isUnique: false,
+    isUpdatedAt: false,
+    // Only emit @relation when the relation is named; an unnamed back-relation
+    // carries no attribute (matches Prisma's formatter output).
+    ...owning.relation?.name ? { relation: { name: owning.relation.name } } : {}
+  });
+}
+function addOwningSide(related, parent, listField) {
+  const ref = idFields(parent)[0];
+  if (!ref) return;
+  const relationField = uniqueFieldName(related, camelCase(parent.name));
+  const fkName = uniqueFieldName(
+    related,
+    `${camelCase(parent.name)}${pascalCase(ref.name)}`
+  );
+  related.fields.push({
+    name: fkName,
+    type: ref.type,
+    kind: "scalar",
+    isList: false,
+    isRequired: true,
+    isId: false,
+    isUnique: false,
+    isUpdatedAt: false,
+    ...ref.nativeType ? { nativeType: ref.nativeType } : {}
+  });
+  related.fields.push({
+    name: relationField,
+    type: parent.name,
+    kind: "object",
+    isList: false,
+    isRequired: true,
+    isId: false,
+    isUnique: false,
+    isUpdatedAt: false,
+    relation: {
+      ...listField.relation?.name ? { name: listField.relation.name } : {},
+      fields: [fkName],
+      references: [ref.name]
+    }
+  });
+}
+function upgradeBareToOne(doc, model, field) {
+  const related = findModel(doc, field.type);
+  if (!related) return;
+  const ref = idFields(related)[0];
+  if (!ref) return;
+  const fkName = uniqueFieldName(model, `${field.name}${pascalCase(ref.name)}`);
+  const idx = model.fields.indexOf(field);
+  model.fields.splice(idx, 0, {
+    name: fkName,
+    type: ref.type,
+    kind: "scalar",
+    isList: false,
+    isRequired: field.isRequired,
+    isId: false,
+    isUnique: false,
+    isUpdatedAt: false,
+    ...ref.nativeType ? { nativeType: ref.nativeType } : {}
+  });
+  field.relation = {
+    ...field.relation ?? {},
+    fields: [fkName],
+    references: [ref.name]
+  };
+  addBackRelation(related, model, field);
+}
+function uniqueFieldName(model, base) {
+  let name = base || "relation";
+  let i = 1;
+  while (model.fields.some((f) => f.name === name)) name = `${base}_${++i}`;
+  return name;
+}
+
+// src/schema/index.ts
+function formatSchema(source, file) {
+  const doc = completeRelations(parseSchema(source, file));
+  validateSchema(doc);
+  return printSchema(doc);
+}
+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((resolve4, reject) => {
+      this.pool.get((err, db) => {
+        if (err) return reject(wrap(err, "Failed to acquire connection"));
+        resolve4(db);
+      });
+    });
+  }
+  begin(db, isolation) {
+    return new Promise((resolve4, reject) => {
+      db.transaction(isolationConstant(isolation), (err, tr) => {
+        if (err) return reject(wrap(err, "Failed to start transaction"));
+        resolve4(tr);
+      });
+    });
+  }
+  runOnTransaction(tr, sql, params = []) {
+    const start = this.onQuery ? performance.now() : 0;
+    return new Promise((resolve4, 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
+          });
+        }
+        resolve4(rows);
+      });
+    });
+  }
+  commit(tr) {
+    return new Promise((resolve4, reject) => {
+      tr.commit((err) => {
+        if (err) return reject(wrap(err, "Failed to commit transaction"));
+        resolve4();
+      });
+    });
+  }
+  safeRollback(tr) {
+    return new Promise((resolve4) => {
+      tr.rollback(() => resolve4());
+    });
+  }
+};
+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;
+}
+
+// src/driver/index.ts
+function createDriver(source, options) {
+  const config = typeof source === "string" ? parseConnectionUrl(source) : source;
+  return new FirebirdDriver(config, options);
+}
+
+// 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/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 = uniqueFieldName2(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 = uniqueFieldName2(
+      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 uniqueFieldName2(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 rel2 of relationFields(model)) {
+      for (const fk of rel2.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 rel2 = f.relation;
+    if (!rel2?.fields?.length) continue;
+    const refModel = schema.models.find((m) => m.name === f.type);
+    if (!refModel) continue;
+    out.push({
+      columns: rel2.fields.map((name) => columnFor(model, name)),
+      refTable: modelTable(refModel),
+      refColumns: (rel2.references ?? []).map((name) => columnFor(refModel, name)),
+      onDelete: rel2.onDelete,
+      onUpdate: rel2.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";
+}
+
+// src/cli/commands.ts
+import { readFileSync as readFileSync3 } from "fs";
+var DEFAULT_SCHEMA = "ember/schema.ember";
+var STARTER_SCHEMA = `datasource db {
+  provider = "firebird"
+  url      = env("DATABASE_URL")
+}
+
+generator client {
+  provider = "ember-client-js"
+  output   = "../generated"
+}
+
+/// Example model \u2014 replace with your own or run \`ember db pull\`.
+model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  name      String?
+  createdAt DateTime @default(now())
+}
+`;
+function init(ctx) {
+  const target = resolve3(ctx.cwd, DEFAULT_SCHEMA);
+  if (existsSync3(target)) {
+    ctx.error(`Schema already exists at ${target}`);
+    return 1;
+  }
+  mkdirSync3(dirname3(target), { recursive: true });
+  writeFileSync3(target, STARTER_SCHEMA, "utf8");
+  ctx.log(`Created ${rel(ctx.cwd, target)}`);
+  ctx.log("Set DATABASE_URL and run `ember db pull` or `ember generate`.");
+  return 0;
+}
+function validate(ctx, schemaPath) {
+  const path = requireSchema(ctx, schemaPath);
+  if (!path) return 1;
+  loadSchema(path);
+  ctx.log(`Schema at ${rel(ctx.cwd, path)} is valid.`);
+  return 0;
+}
+function format(ctx, schemaPath) {
+  const path = requireSchema(ctx, schemaPath);
+  if (!path) return 1;
+  const source = readFileSync3(path, "utf8");
+  writeFileSync3(path, formatSchema(source, path), "utf8");
+  ctx.log(`Formatted ${rel(ctx.cwd, path)}`);
+  return 0;
+}
+function generate(ctx, schemaPath) {
+  const path = requireSchema(ctx, schemaPath);
+  if (!path) return 1;
+  const { document } = loadSchema(path);
+  const gen = document.generators[0];
+  const out = resolve3(dirname3(path), gen?.output ?? "../generated");
+  const file = writeClient(document, out);
+  ctx.log(`Generated client at ${rel(ctx.cwd, file)}`);
+  return 0;
+}
+async function dbPull(ctx, options) {
+  const path = findSchemaPath(ctx.cwd, options.schemaPath) ?? resolve3(ctx.cwd, DEFAULT_SCHEMA);
+  let url = options.url;
+  let envVar = "DATABASE_URL";
+  if (!url && existsSync3(path)) {
+    const { document } = loadSchema(path);
+    url = resolveDatasourceUrl(document, dirname3(path));
+    if (document.datasource?.url.kind === "env") {
+      envVar = document.datasource.url.value;
+    }
+  }
+  url ??= process.env.DATABASE_URL;
+  if (!url) {
+    ctx.error(
+      "No database URL. Set DATABASE_URL, pass --url, or add a datasource block."
+    );
+    return 1;
+  }
+  const driver = createDriver(url);
+  try {
+    await driver.connect();
+    const introspector = new Introspector(driver);
+    const document = await introspector.introspect({
+      datasource: { name: "db", provider: "firebird", envVar }
+    });
+    mkdirSync3(dirname3(path), { recursive: true });
+    writeFileSync3(path, printSchema(document), "utf8");
+    ctx.log(
+      `Introspected ${document.models.length} model(s) into ${rel(ctx.cwd, path)}`
+    );
+    return 0;
+  } finally {
+    await driver.disconnect();
+  }
+}
+async function migrateDev(ctx, options) {
+  return withMigrator(ctx, options, async (migrator) => {
+    const result = await migrator.dev(options.name ?? "migration");
+    if (result.empty) {
+      ctx.log("No schema changes \u2014 database already in sync.");
+      return 0;
+    }
+    ctx.log(`Created and applied migration ${result.id} (${result.statements.length} step(s)).`);
+    return 0;
+  });
+}
+async function migrateDeploy(ctx, options) {
+  return withMigrator(ctx, options, async (migrator) => {
+    const { applied } = await migrator.deploy();
+    if (applied.length === 0) {
+      ctx.log("No pending migrations.");
+      return 0;
+    }
+    for (const m of applied) ctx.log(`Applied ${m.id} (${m.steps} step(s)).`);
+    return 0;
+  });
+}
+async function migrateStatus(ctx, options) {
+  return withMigrator(ctx, options, async (migrator) => {
+    const { applied, pending } = await migrator.status();
+    ctx.log(`Applied (${applied.length}):`);
+    for (const id of applied) ctx.log(`  \u2713 ${id}`);
+    ctx.log(`Pending (${pending.length}):`);
+    for (const id of pending) ctx.log(`  \u2022 ${id}`);
+    return 0;
+  });
+}
+async function dbPush(ctx, options) {
+  return withMigrator(ctx, options, async (migrator) => {
+    const { statements } = await migrator.push();
+    if (statements.length === 0) {
+      ctx.log("No schema changes \u2014 database already in sync.");
+      return 0;
+    }
+    ctx.log(`Applied ${statements.length} statement(s) to the database.`);
+    return 0;
+  });
+}
+async function withMigrator(ctx, options, fn) {
+  const path = requireSchema(ctx, options.schemaPath);
+  if (!path) return 1;
+  const { document } = loadSchema(path);
+  const url = options.url ?? resolveDatasourceUrl(document, dirname3(path)) ?? process.env.DATABASE_URL;
+  if (!url) {
+    ctx.error(
+      "No database URL. Set DATABASE_URL, pass --url, or add a datasource block."
+    );
+    return 1;
+  }
+  const migrationsDir = resolve3(dirname3(path), "migrations");
+  const config = parseConnectionUrl(url);
+  const dialect = new FirebirdDialect({ version: config.version });
+  const driver = createDriver(config);
+  try {
+    await driver.connect();
+    const migrator = new Migrator(driver, document, migrationsDir, dialect);
+    return await fn(migrator);
+  } finally {
+    await driver.disconnect();
+  }
+}
+function requireSchema(ctx, schemaPath) {
+  const path = findSchemaPath(ctx.cwd, schemaPath);
+  if (!path) {
+    ctx.error(
+      `Schema not found. Expected ${DEFAULT_SCHEMA} (or pass --schema). Run \`ember init\` to create one.`
+    );
+    return null;
+  }
+  return path;
+}
+function rel(cwd, target) {
+  return target.startsWith(cwd) ? target.slice(cwd.length + 1) : target;
+}
+
+// src/cli/bin.ts
+var HELP = `EmberORM \u2014 Prisma-like ORM for Firebird
+
+Usage: ember <command> [options]
+
+Commands:
+  init                 Scaffold ember/schema.ember
+  db pull              Introspect the database into your schema
+  db push              Apply schema changes directly (no migration file)
+  generate             Generate the typed client from the schema
+  migrate dev          Diff, create a migration file, and apply it
+  migrate deploy       Apply all pending migration files
+  migrate status       Show applied vs pending migrations
+  format               Re-print the schema with canonical formatting
+  validate             Parse and validate the schema
+
+Options:
+  --schema <path>      Path to the schema file
+  --url <url>          Firebird connection URL (overrides datasource/env)
+  --name <name>        Migration name (migrate dev)
+  -h, --help           Show this help
+  -v, --version        Show version
+`;
+function parseArgs(argv) {
+  const command = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next && !next.startsWith("-")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg === "-h") {
+      flags.help = true;
+    } else if (arg === "-v") {
+      flags.version = true;
+    } else {
+      command.push(arg);
+    }
+  }
+  return { command, flags };
+}
+async function main() {
+  const { command, flags } = parseArgs(process.argv.slice(2));
+  const ctx = {
+    cwd: process.cwd(),
+    log: (m) => process.stdout.write(m + "\n"),
+    error: (m) => process.stderr.write(`error: ${m}
+`)
+  };
+  if (flags.version) {
+    ctx.log(readVersion());
+    return 0;
+  }
+  if (flags.help || command.length === 0) {
+    ctx.log(HELP);
+    return command.length === 0 ? 1 : 0;
+  }
+  const schemaPath = typeof flags.schema === "string" ? flags.schema : void 0;
+  const url = typeof flags.url === "string" ? flags.url : void 0;
+  const name = typeof flags.name === "string" ? flags.name : void 0;
+  const [first, second] = command;
+  switch (first) {
+    case "init":
+      return init(ctx);
+    case "validate":
+      return validate(ctx, schemaPath);
+    case "format":
+      return format(ctx, schemaPath);
+    case "generate":
+      return generate(ctx, schemaPath);
+    case "db":
+      if (second === "pull") return dbPull(ctx, { schemaPath, url });
+      if (second === "push") return dbPush(ctx, { schemaPath, url });
+      ctx.error(`Unknown db subcommand '${second ?? ""}'.`);
+      return 1;
+    case "migrate":
+      if (second === "dev") return migrateDev(ctx, { schemaPath, url, name });
+      if (second === "deploy") return migrateDeploy(ctx, { schemaPath, url });
+      if (second === "status") return migrateStatus(ctx, { schemaPath, url });
+      ctx.error(`Unknown migrate subcommand '${second ?? ""}'.`);
+      return 1;
+    default:
+      ctx.error(`Unknown command '${first}'. Run 'ember --help'.`);
+      return 1;
+  }
+}
+function readVersion() {
+  for (const candidate of ["../../package.json", "../package.json"]) {
+    try {
+      const url = new URL(candidate, import.meta.url);
+      const pkg = JSON.parse(readFileSync4(fileURLToPath(url), "utf8"));
+      if (pkg?.version) return `ember ${pkg.version}`;
+    } catch {
+    }
+  }
+  return "ember (unknown version)";
+}
+main().then((code) => process.exit(code)).catch((err) => {
+  if (err instanceof EmberError) {
+    process.stderr.write(`error: ${err.message}
+`);
+  } else {
+    process.stderr.write(`unexpected error: ${err.stack ?? err}
+`);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=bin.js.map