@active-record-ts/active-model 1.0.0 → 1.1.0

package/dist/index.js

@@ -0,0 +1,1808 @@
+// src/Type.ts
+var isNullish = (value) => value === null || value === void 0;
+var StringType = class {
+  type = "string";
+  cast(value) {
+    if (isNullish(value)) return null;
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
+    if (value instanceof Date) return value.toISOString();
+    return String(value);
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+};
+var IntegerType = class {
+  type = "integer";
+  cast(value) {
+    if (isNullish(value) || value === "") return null;
+    if (typeof value === "number") return Number.isFinite(value) ? Math.trunc(value) : null;
+    if (typeof value === "bigint") return Number(value);
+    if (typeof value === "boolean") return value ? 1 : 0;
+    if (typeof value === "string") {
+      const parsed = Number.parseInt(value, 10);
+      return Number.isNaN(parsed) ? null : parsed;
+    }
+    return null;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+};
+var BigIntType = class {
+  type = "bigint";
+  cast(value) {
+    if (isNullish(value) || value === "") return null;
+    if (typeof value === "bigint") return value;
+    if (typeof value === "number") return Number.isFinite(value) ? BigInt(Math.trunc(value)) : null;
+    if (typeof value === "string") {
+      try {
+        return BigInt(value);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+};
+var FloatType = class {
+  type = "float";
+  cast(value) {
+    if (isNullish(value) || value === "") return null;
+    if (typeof value === "number") return Number.isFinite(value) ? value : null;
+    if (typeof value === "bigint") return Number(value);
+    if (typeof value === "string") {
+      const parsed = Number.parseFloat(value);
+      return Number.isNaN(parsed) ? null : parsed;
+    }
+    if (typeof value === "boolean") return value ? 1 : 0;
+    return null;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+};
+var DecimalType = class {
+  type = "decimal";
+  cast(value) {
+    if (isNullish(value) || value === "") return null;
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "bigint") return String(value);
+    return String(value);
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+};
+var TRUTHY = /* @__PURE__ */ new Set(["1", "t", "T", "true", "TRUE", "on", "ON", 1, true]);
+var FALSY = /* @__PURE__ */ new Set(["0", "f", "F", "false", "FALSE", "off", "OFF", 0, false]);
+var BooleanType = class {
+  type = "boolean";
+  cast(value) {
+    if (isNullish(value) || value === "") return null;
+    if (TRUTHY.has(value)) return true;
+    if (FALSY.has(value)) return false;
+    return Boolean(value);
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+};
+var dateOnly = (date) => {
+  const d = new Date(date.getTime());
+  d.setUTCHours(0, 0, 0, 0);
+  return d;
+};
+var DateType = class {
+  type = "date";
+  cast(value) {
+    if (isNullish(value) || value === "") return null;
+    if (value instanceof Date) return dateOnly(value);
+    if (typeof value === "string") {
+      const d = new Date(/^\d{4}-\d{2}-\d{2}$/.test(value) ? `${value}T00:00:00.000Z` : value);
+      return Number.isNaN(d.getTime()) ? null : dateOnly(d);
+    }
+    if (typeof value === "number") {
+      const d = new Date(value);
+      return Number.isNaN(d.getTime()) ? null : dateOnly(d);
+    }
+    return null;
+  }
+  serialize(value) {
+    if (value == null) return null;
+    return value.toISOString().slice(0, 10);
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+  equals(a, b) {
+    if (a == null || b == null) return a === b;
+    return a.getTime() === b.getTime();
+  }
+};
+var DateTimeType = class {
+  type = "datetime";
+  cast(value) {
+    if (isNullish(value) || value === "") return null;
+    if (value instanceof Date) return new Date(value.getTime());
+    if (typeof value === "string") {
+      const d = new Date(value);
+      return Number.isNaN(d.getTime()) ? null : d;
+    }
+    if (typeof value === "number") {
+      const d = new Date(value);
+      return Number.isNaN(d.getTime()) ? null : d;
+    }
+    return null;
+  }
+  serialize(value) {
+    if (value == null) return null;
+    return value.toISOString();
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+  equals(a, b) {
+    if (a == null || b == null) return a === b;
+    return a.getTime() === b.getTime();
+  }
+};
+var JSONType = class {
+  type = "json";
+  cast(value) {
+    if (isNullish(value)) return null;
+    if (typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return null;
+      }
+    }
+    return value;
+  }
+  serialize(value) {
+    if (value == null) return null;
+    return JSON.stringify(value);
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+};
+var BinaryType = class {
+  type = "binary";
+  cast(value) {
+    if (isNullish(value)) return null;
+    if (value instanceof Uint8Array) return value;
+    if (typeof value === "string") return new TextEncoder().encode(value);
+    if (Array.isArray(value)) return new Uint8Array(value);
+    return null;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return this.cast(value);
+  }
+  equals(a, b) {
+    if (a == null || b == null) return a === b;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+    return true;
+  }
+};
+var ValueType = class {
+  type = "value";
+  cast(value) {
+    return isNullish(value) ? null : value;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return isNullish(value) ? null : value;
+  }
+};
+var valuesEqual = (type, a, b) => type.equals ? type.equals(a, b) : a === b;
+var REGISTRY = /* @__PURE__ */ new Map();
+var registerType = (name, factory) => {
+  REGISTRY.set(name, factory);
+};
+var lookupType = (name) => {
+  const factory = REGISTRY.get(name);
+  if (!factory) throw new Error(`Unknown attribute type: ${name}`);
+  return factory();
+};
+var hasType = (name) => REGISTRY.has(name);
+registerType("string", () => new StringType());
+registerType("text", () => new StringType());
+registerType("integer", () => new IntegerType());
+registerType("int", () => new IntegerType());
+registerType("bigint", () => new BigIntType());
+registerType("float", () => new FloatType());
+registerType("double", () => new FloatType());
+registerType("decimal", () => new DecimalType());
+registerType("numeric", () => new DecimalType());
+registerType("boolean", () => new BooleanType());
+registerType("bool", () => new BooleanType());
+registerType("date", () => new DateType());
+registerType("datetime", () => new DateTimeType());
+registerType("timestamp", () => new DateTimeType());
+registerType("time", () => new DateTimeType());
+registerType("json", () => new JSONType());
+registerType("jsonb", () => new JSONType());
+registerType("binary", () => new BinaryType());
+registerType("blob", () => new BinaryType());
+registerType("bytea", () => new BinaryType());
+registerType("value", () => new ValueType());
+
+// src/AttributeSet.ts
+var AttributeSet = class _AttributeSet {
+  definitions = /* @__PURE__ */ new Map();
+  /** Insertion-ordered list of attribute names, for stable iteration. */
+  names = [];
+  /** Register an attribute (or replace an existing one). */
+  define(definition) {
+    if (!this.definitions.has(definition.name)) this.names.push(definition.name);
+    this.definitions.set(definition.name, definition);
+  }
+  has(name) {
+    return this.definitions.has(name);
+  }
+  get(name) {
+    return this.definitions.get(name);
+  }
+  keys() {
+    return this.names.slice();
+  }
+  /** Stable iteration of definitions in declaration order. */
+  *[Symbol.iterator]() {
+    for (const name of this.names) yield this.definitions.get(name);
+  }
+  size() {
+    return this.definitions.size;
+  }
+  clone() {
+    const copy = new _AttributeSet();
+    for (const def of this) copy.define(def);
+    return copy;
+  }
+};
+var Attributes = class {
+  constructor(set) {
+    this.set = set;
+  }
+  set;
+  current = /* @__PURE__ */ new Map();
+  original = /* @__PURE__ */ new Map();
+  previousChanges = /* @__PURE__ */ new Map();
+  accessedNames = /* @__PURE__ */ new Set();
+  /** Hydrate attributes after loading from the DB. Skips dirty tracking. */
+  hydrate(raw) {
+    for (const def of this.set) {
+      const incoming = raw[def.name];
+      const value = def.type.deserialize(incoming);
+      this.current.set(def.name, value);
+      this.original.set(def.name, value);
+    }
+  }
+  /** Hydrate attributes for a brand-new record (applies defaults). */
+  hydrateDefaults(overrides = {}) {
+    for (const def of this.set) {
+      const provided = def.name in overrides;
+      const raw = provided ? overrides[def.name] : def.default;
+      const value = def.type.cast(raw);
+      this.current.set(def.name, value);
+      this.original.set(def.name, value);
+    }
+  }
+  /** Read an attribute by name, returning the canonical (cast) value. */
+  read(name) {
+    this.accessedNames.add(name);
+    return this.current.get(name);
+  }
+  /** Names that have been read since hydration. Mirrors Rails' `accessed_attributes`. */
+  accessed() {
+    return [...this.accessedNames].filter((n) => this.set.has(n));
+  }
+  /** Write an attribute by name. Type-casts before storing. */
+  write(name, value) {
+    const def = this.set.get(name);
+    if (!def) {
+      this.current.set(name, value);
+      return;
+    }
+    this.current.set(name, def.type.cast(value));
+  }
+  /**
+   * Explicitly mark `name` as having been mutated in place — without
+   * actually writing a new value. Mirrors Rails' `name_will_change!`
+   * which captures the current value into the original snapshot for
+   * later mutation detection.
+   */
+  willChange(name) {
+    if (!this.current.has(name) && !this.original.has(name)) return;
+    const value = this.current.get(name);
+    const snapshot = typeof value === "object" && value !== null ? Array.isArray(value) ? [...value] : { ...value } : value;
+    this.original.set(name, snapshot);
+  }
+  /** Was this attribute changed since the last commit? */
+  changed(name) {
+    if (!this.current.has(name)) return false;
+    const def = this.set.get(name);
+    const original = this.original.get(name);
+    const value = this.current.get(name);
+    if (!def) return original !== value;
+    return !valuesEqual(def.type, original, value);
+  }
+  /** List of attribute names that differ from their originals. */
+  changedAttributes() {
+    const result = [];
+    for (const name of this.set.keys()) {
+      if (this.changed(name)) result.push(name);
+    }
+    return result;
+  }
+  /** `{ name: [from, to] }` for every changed attribute. */
+  changes() {
+    const out = {};
+    for (const name of this.changedAttributes()) {
+      out[name] = [this.original.get(name), this.current.get(name)];
+    }
+    return out;
+  }
+  /** Original value of `name` (current value if unchanged). */
+  was(name) {
+    return this.original.get(name);
+  }
+  /** Snapshot for SAVE — return the canonical values for each attribute. */
+  toHash() {
+    const out = {};
+    for (const name of this.set.keys()) out[name] = this.current.get(name);
+    return out;
+  }
+  /** Snapshot of only the dirty attributes (for UPDATE statements). */
+  dirtyHash() {
+    const out = {};
+    for (const name of this.changedAttributes()) out[name] = this.current.get(name);
+    return out;
+  }
+  /** Serialized snapshot of all attributes (driver-ready values). */
+  serializedHash() {
+    const out = {};
+    for (const def of this.set) {
+      out[def.name] = def.type.serialize(this.current.get(def.name));
+    }
+    return out;
+  }
+  /** Mark the current values as the new baseline. Captures previous changes. */
+  commit() {
+    const previous = /* @__PURE__ */ new Map();
+    for (const name of this.changedAttributes()) {
+      previous.set(name, [this.original.get(name), this.current.get(name)]);
+      this.original.set(name, this.current.get(name));
+    }
+    this.previousChanges = previous;
+  }
+  /** Drop all pending and recorded changes — used by `clearChangesInformation`. */
+  clearChanges() {
+    for (const [name, value] of this.current) this.original.set(name, value);
+    this.previousChanges = /* @__PURE__ */ new Map();
+  }
+  /** Revert all pending changes. */
+  restore() {
+    for (const name of this.changedAttributes()) {
+      this.current.set(name, this.original.get(name));
+    }
+  }
+  /** Changes that were applied during the last `commit`. */
+  savedChanges() {
+    const out = {};
+    for (const [name, pair] of this.previousChanges) out[name] = pair;
+    return out;
+  }
+  attributeSet() {
+    return this.set;
+  }
+};
+
+// src/Callbacks.ts
+var HaltError = class extends Error {
+  constructor() {
+    super("Callback chain halted");
+  }
+};
+var ABORT_SENTINEL = /* @__PURE__ */ Symbol.for("@active-record-ts/active-model:abort");
+var throwAbort = () => {
+  throw ABORT_SENTINEL;
+};
+var CallbackChain = class {
+  chains = {
+    validation: [],
+    save: [],
+    create: [],
+    update: [],
+    destroy: [],
+    commit: [],
+    rollback: [],
+    initialize: [],
+    find: [],
+    touch: []
+  };
+  /** Register a new callback under `event` of `kind`. */
+  add(event, kind, fn, options) {
+    this.chains[event].push({ kind, fn, if: options?.if, unless: options?.unless, on: options?.on });
+  }
+  /** Copy chains from a parent so subclasses inherit before extending. */
+  inheritFrom(parent) {
+    for (const event of Object.keys(this.chains)) {
+      this.chains[event] = [...parent.chains[event]];
+    }
+  }
+  /**
+   * Run the chain around `body`. Returns `false` when a `before` callback
+   * halts; otherwise returns the return value of `body`. Pass a `context`
+   * to filter callbacks registered with `on:` — primarily used for
+   * validation contexts (`create`/`update`) but available everywhere.
+   */
+  async run(event, record, body, context) {
+    const entries = this.chains[event];
+    const befores = entries.filter((e) => e.kind === "before");
+    const afters = entries.filter((e) => e.kind === "after");
+    const arounds = entries.filter((e) => e.kind === "around");
+    for (const entry of befores) {
+      if (!guard(entry, record, context)) continue;
+      try {
+        const result = await entry.fn(record);
+        if (result === false) return false;
+      } catch (err) {
+        if (err instanceof HaltError) return false;
+        if (err === ABORT_SENTINEL) return false;
+        throw err;
+      }
+    }
+    let bodyHalted = false;
+    if (arounds.length === 0) {
+      const r = await body();
+      if (r === false) bodyHalted = true;
+    } else {
+      const bodyRunner = async () => {
+        const r = await body();
+        if (r === false) bodyHalted = true;
+      };
+      let runner = bodyRunner;
+      for (let i = arounds.length - 1; i >= 0; i--) {
+        const around = arounds[i];
+        if (!around || !guard(around, record, context)) continue;
+        const inner = runner;
+        runner = () => around.fn(record, inner);
+      }
+      await runner();
+    }
+    if (bodyHalted) return false;
+    for (const entry of afters) {
+      if (!guard(entry, record, context)) continue;
+      try {
+        await entry.fn(record);
+      } catch (err) {
+        if (err instanceof HaltError) break;
+        if (err === ABORT_SENTINEL) break;
+        throw err;
+      }
+    }
+    return true;
+  }
+};
+var guard = (entry, record, context) => {
+  if (entry.on !== void 0) {
+    const wanted = Array.isArray(entry.on) ? entry.on : [entry.on];
+    if (context === void 0) return false;
+    if (!wanted.includes(context)) return false;
+  }
+  if (entry.if && !entry.if(record)) return false;
+  if (entry.unless && entry.unless(record)) return false;
+  return true;
+};
+
+// src/Errors.ts
+var ErrorObject = class {
+  constructor(entry) {
+    this.entry = entry;
+  }
+  entry;
+  get attribute() {
+    return this.entry.attribute;
+  }
+  get message() {
+    return this.entry.message;
+  }
+  get type() {
+    return this.entry.type;
+  }
+  get options() {
+    return this.entry.options;
+  }
+  fullMessage() {
+    return this.entry.attribute === BASE ? this.entry.message : `${humanize(this.entry.attribute)} ${this.entry.message}`;
+  }
+  /** Internal accessor for `Errors#import` — returns the wrapped entry. */
+  toEntry() {
+    return this.entry;
+  }
+};
+var BASE = "base";
+var DEFAULT_MESSAGES = {
+  invalid: "is invalid",
+  blank: "can't be blank",
+  present: "must be blank",
+  too_short: "is too short (minimum is %{count} characters)",
+  too_long: "is too long (maximum is %{count} characters)",
+  wrong_length: "is the wrong length (should be %{count} characters)",
+  taken: "has already been taken",
+  not_a_number: "is not a number",
+  greater_than: "must be greater than %{count}",
+  greater_than_or_equal_to: "must be greater than or equal to %{count}",
+  less_than: "must be less than %{count}",
+  less_than_or_equal_to: "must be less than or equal to %{count}",
+  equal_to: "must be equal to %{count}",
+  odd: "must be odd",
+  even: "must be even",
+  inclusion: "is not included in the list",
+  exclusion: "is reserved",
+  accepted: "must be accepted",
+  confirmation: "doesn't match %{attribute}",
+  empty: "can't be empty"
+};
+var isKnownType = (value) => Object.hasOwn(DEFAULT_MESSAGES, value);
+var interpolate = (template, options = {}) => template.replace(/%\{(\w+)\}/g, (_, key) => key in options ? String(options[key]) : `%{${key}}`);
+var Errors = class _Errors {
+  entries = [];
+  /**
+   * Record an error. The second argument can be:
+   *  - a free-form message string (e.g. `errors.add('name', "can't be empty")`)
+   *  - a known symbol-style type that resolves to a default message
+   *    (e.g. `errors.add('name', 'blank')` -> "can't be blank")
+   *
+   * Pass extra interpolation values or a custom `type` via the third arg.
+   */
+  add(attribute, messageOrType = "invalid", options = {}) {
+    const {
+      type: explicitType,
+      options: explicitOptions,
+      message: explicitMessage,
+      ...payload
+    } = options;
+    const mergedOptions = { ...payload, ...explicitOptions ?? {} };
+    let type;
+    let message;
+    if (explicitType) {
+      type = explicitType;
+      message = explicitMessage ?? (isKnownType(messageOrType) ? interpolate(DEFAULT_MESSAGES[messageOrType], mergedOptions) : messageOrType);
+    } else if (isKnownType(messageOrType)) {
+      type = messageOrType;
+      message = explicitMessage ?? interpolate(DEFAULT_MESSAGES[messageOrType], mergedOptions);
+    } else {
+      message = explicitMessage ?? messageOrType;
+    }
+    const entry = {
+      attribute,
+      message,
+      ...type !== void 0 ? { type } : {},
+      ...Object.keys(mergedOptions).length > 0 ? { options: mergedOptions } : {}
+    };
+    this.entries.push(entry);
+    return entry;
+  }
+  /** True when there are no errors at all. */
+  get empty() {
+    return this.entries.length === 0;
+  }
+  /** True when at least one error has been recorded. */
+  get any() {
+    return this.entries.length > 0;
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+  delete(attribute, type, matchOptions) {
+    const deleted = [];
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const e = this.entries[i];
+      if (e.attribute !== attribute) continue;
+      if (type !== void 0 && e.type !== type) continue;
+      if (matchOptions && !matchesOptions(e.options, matchOptions)) continue;
+      deleted.unshift(e.message);
+      this.entries.splice(i, 1);
+    }
+    return deleted;
+  }
+  on(attribute) {
+    return this.entries.filter((e) => e.attribute === attribute).map((e) => e.message);
+  }
+  includes(attribute) {
+    return this.entries.some((e) => e.attribute === attribute);
+  }
+  /** All `[attribute, message]` pairs, in insertion order. */
+  get messages() {
+    const out = {};
+    for (const entry of this.entries) {
+      const bucket = out[entry.attribute] ?? [];
+      bucket.push(entry.message);
+      out[entry.attribute] = bucket;
+    }
+    return out;
+  }
+  /** Distinct attributes that currently carry at least one error. */
+  get attributeNames() {
+    const seen = /* @__PURE__ */ new Set();
+    const ordered = [];
+    for (const entry of this.entries) {
+      if (!seen.has(entry.attribute)) {
+        seen.add(entry.attribute);
+        ordered.push(entry.attribute);
+      }
+    }
+    return ordered;
+  }
+  /** Predicate: was an error matching the given attribute (and optional type / options) added? */
+  added(attribute, type, matchOptions) {
+    return this.entries.some((e) => {
+      if (e.attribute !== attribute) return false;
+      if (type !== void 0 && e.type !== type) return false;
+      if (matchOptions && !matchesOptions(e.options, matchOptions)) return false;
+      return true;
+    });
+  }
+  /** Filter entries by attribute / type / options. */
+  where(attribute, type, matchOptions) {
+    return this.entries.filter((e) => {
+      if (e.attribute !== attribute) return false;
+      if (type !== void 0 && e.type !== type) return false;
+      if (matchOptions && !matchesOptions(e.options, matchOptions)) return false;
+      return true;
+    });
+  }
+  /** Messages for a specific attribute, optionally filtered by type. */
+  messagesFor(attribute, type) {
+    return this.where(attribute, type).map((e) => e.message);
+  }
+  /** Human-readable strings like `"Name can't be blank"`. */
+  get fullMessages() {
+    return this.entries.map((e) => e.attribute === BASE ? e.message : `${humanize(e.attribute)} ${e.message}`);
+  }
+  fullMessagesFor(attribute, type) {
+    return this.where(attribute, type).map(
+      (e) => attribute === BASE ? e.message : `${humanize(attribute)} ${e.message}`
+    );
+  }
+  /** Standalone full-message formatter (no entries side effect). */
+  fullMessage(attribute, message) {
+    return attribute === BASE ? message : `${humanize(attribute)} ${message}`;
+  }
+  /** Append every entry from `other` to this collection. */
+  merge(other) {
+    if (other === this) return this;
+    for (const entry of other.entries)
+      this.entries.push({ ...entry, options: entry.options ? { ...entry.options } : void 0 });
+    return this;
+  }
+  /** Replace this collection's entries with copies of another's. */
+  copy(other) {
+    this.clear();
+    return this.merge(other);
+  }
+  /**
+   * Return a new `Errors` collection with the same entries. Subsequent
+   * modifications on either side don't affect the other.
+   */
+  dup() {
+    const copy = new _Errors();
+    copy.merge(this);
+    return copy;
+  }
+  /** Rich `ErrorObject` instances for each entry, in insertion order. */
+  get objects() {
+    return this.entries.map((e) => new ErrorObject(e));
+  }
+  /** First error (rich object) or `null`. */
+  get first() {
+    return this.entries[0] ? new ErrorObject(this.entries[0]) : null;
+  }
+  /**
+   * Structured details payload. Each attribute maps to a list of
+   * `{ error: type, ...options }` records. Mirrors Rails' `errors.details`.
+   */
+  get details() {
+    const out = {};
+    for (const entry of this.entries) {
+      const bucket = out[entry.attribute] ?? [];
+      bucket.push({ error: entry.type, ...entry.options ?? {} });
+      out[entry.attribute] = bucket;
+    }
+    return out;
+  }
+  /** Group rich error objects by attribute. */
+  groupByAttribute() {
+    const out = {};
+    for (const entry of this.entries) {
+      const bucket = out[entry.attribute] ?? [];
+      bucket.push(new ErrorObject(entry));
+      out[entry.attribute] = bucket;
+    }
+    return out;
+  }
+  /** Indifferent indexer — `errors.get('name')` is equivalent to `errors.on('name')`. */
+  get(attribute) {
+    return this.on(attribute);
+  }
+  /**
+   * Remove duplicate entries — same attribute + message + type. Mirrors
+   * Rails' `errors.uniq!`.
+   */
+  uniq() {
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const e = this.entries[i];
+      const key = `${e.attribute}\0${e.message}\0${e.type ?? ""}`;
+      if (seen.has(key)) this.entries.splice(i, 1);
+      else seen.add(key);
+    }
+    return this;
+  }
+  /** Import a foreign `ErrorEntry` or `ErrorObject`, optionally overriding attribute/type. */
+  import(error, overrides = {}) {
+    const base = error instanceof ErrorObject ? error.toEntry() : error;
+    const next = {
+      attribute: overrides.attribute ?? base.attribute,
+      message: base.message,
+      type: overrides.type ?? base.type,
+      options: base.options ? { ...base.options } : void 0
+    };
+    this.entries.push(next);
+    return next;
+  }
+  /**
+   * Indifferent indexer — returns `errors.on(attribute)` via a Proxy
+   * pseudo-property, supporting both `errors.byAttribute('name')` and
+   * the bracket-access shape `(errors as any)['name']`. Mirrors Rails'
+   * `errors[:name]` / `errors['name']`. (We can't do real bracket access
+   * without wrapping every Errors instance in a Proxy; this method-style
+   * accessor is the idiomatic TS equivalent.)
+   */
+  byAttribute(attribute) {
+    return this.on(attribute);
+  }
+  /**
+   * Rails-style `as_json`. With `{ fullMessages: true }`, each entry is
+   * the humanized "Attribute msg" form. Default returns the same shape
+   * as `messages`.
+   */
+  asJson(options = {}) {
+    if (!options.fullMessages) return this.messages;
+    const out = {};
+    for (const entry of this.entries) {
+      const full = entry.attribute === BASE ? entry.message : `${humanize(entry.attribute)} ${entry.message}`;
+      const bucket = out[entry.attribute] ?? [];
+      bucket.push(full);
+      out[entry.attribute] = bucket;
+    }
+    return out;
+  }
+  /**
+   * `to_hash(true)` returns full-message variant; otherwise plain messages.
+   * Convenience shim over `asJson({ fullMessages })`.
+   */
+  toHash(fullMessages = false) {
+    return this.asJson({ fullMessages });
+  }
+  /**
+   * `of_kind?` — true when an entry exists whose attribute and type-or-
+   * message both match. Mirrors Rails' `errors.of_kind?(:name, :blank)`.
+   */
+  ofKind(attribute, typeOrMessage) {
+    if (typeOrMessage === void 0) return this.includes(attribute);
+    return this.entries.some((e) => {
+      if (e.attribute !== attribute) return false;
+      return e.type === typeOrMessage || e.message === typeOrMessage;
+    });
+  }
+  /** Debug-friendly string representation. */
+  inspect() {
+    const parts = this.entries.map((e) => `#<Error attribute=${e.attribute}, message=${JSON.stringify(e.message)}>`);
+    return `#<Errors:[${parts.join(", ")}]>`;
+  }
+  get count() {
+    return this.entries.length;
+  }
+  get size() {
+    return this.entries.length;
+  }
+  [Symbol.iterator]() {
+    return this.entries[Symbol.iterator]();
+  }
+  toJSON() {
+    return this.messages;
+  }
+};
+var matchesOptions = (actual, expected) => {
+  if (!actual) return Object.keys(expected).length === 0;
+  for (const [k, v] of Object.entries(expected)) {
+    if (actual[k] !== v) return false;
+  }
+  return true;
+};
+var humanize = (attribute) => {
+  const flattened = attribute.replace(/\./g, "_");
+  const spaced = flattened.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+};
+
+// src/Validator.ts
+var blank = (value) => {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (value instanceof Set || value instanceof Map) return value.size === 0;
+  return false;
+};
+var StrictValidationFailed = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+var shouldValidate = (record, options = {}, context) => {
+  if (options.on !== void 0) {
+    const wanted = Array.isArray(options.on) ? options.on : [options.on];
+    if (context === void 0) return false;
+    if (!wanted.includes(context)) return false;
+  }
+  if (options.exceptOn !== void 0 && context !== void 0) {
+    const excluded = Array.isArray(options.exceptOn) ? options.exceptOn : [options.exceptOn];
+    if (excluded.includes(context)) return false;
+  }
+  if (options.if && !options.if(record)) return false;
+  if (options.unless && options.unless(record)) return false;
+  return true;
+};
+var skipForNullable = (value, options = {}) => {
+  if (options.allowNull && (value === null || value === void 0)) return true;
+  if (options.allowBlank && blank(value)) return true;
+  return false;
+};
+var reader = (attribute) => (r) => r[attribute];
+var recordError = (options, errors, attribute, defaultMessage, meta = {}, record, value) => {
+  let message;
+  if (typeof options.message === "function") {
+    if (record === void 0) {
+      message = defaultMessage;
+    } else {
+      message = options.message(record, { attribute, value, type: meta.type });
+    }
+  } else if (typeof options.message === "string") {
+    message = options.message;
+  } else {
+    message = defaultMessage;
+  }
+  if (options.strict) {
+    const fullMessage = errors.fullMessage(attribute, message);
+    if (typeof options.strict === "function") {
+      throw new options.strict(fullMessage);
+    }
+    throw new StrictValidationFailed(fullMessage);
+  }
+  errors.add(attribute, message, meta);
+};
+var BlockValidator = class {
+  constructor(fn, options = {}) {
+    this.fn = fn;
+    this.options = options;
+  }
+  fn;
+  options;
+  kind = "block";
+  attributes = [];
+  async validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    await this.fn(record, errors, context);
+  }
+};
+var PresenceValidator = class {
+  constructor(attribute, options = {}) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "presence";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const value = reader(this.attribute)(record);
+    if (blank(value)) {
+      recordError(this.options, errors, this.attribute, "can't be blank", { type: "presence" }, record, value);
+    }
+  }
+};
+var AbsenceValidator = class {
+  constructor(attribute, options = {}) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "absence";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const value = reader(this.attribute)(record);
+    if (!blank(value)) {
+      recordError(this.options, errors, this.attribute, "must be blank", { type: "absence" }, record, value);
+    }
+  }
+};
+var LengthValidator = class {
+  constructor(attribute, options = {}) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "length";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const value = reader(this.attribute)(record);
+    if (skipForNullable(value, this.options)) return;
+    const len = lengthOf(value);
+    const o = this.options;
+    if (o.in) {
+      const [min, max] = o.in;
+      if (len < min) {
+        recordError(
+          this.options,
+          errors,
+          this.attribute,
+          o.tooShort ?? `is too short (minimum is ${min} characters)`,
+          { type: "length" },
+          record,
+          value
+        );
+        return;
+      }
+      if (len > max) {
+        recordError(
+          this.options,
+          errors,
+          this.attribute,
+          o.tooLong ?? `is too long (maximum is ${max} characters)`,
+          { type: "length" },
+          record,
+          value
+        );
+        return;
+      }
+    }
+    if (o.is !== void 0 && len !== o.is) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        o.wrongLength ?? `is the wrong length (should be ${o.is} characters)`,
+        { type: "length" },
+        record,
+        value
+      );
+      return;
+    }
+    if (o.minimum !== void 0 && len < o.minimum) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        o.tooShort ?? `is too short (minimum is ${o.minimum} characters)`,
+        { type: "length" },
+        record,
+        value
+      );
+      return;
+    }
+    if (o.maximum !== void 0 && len > o.maximum) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        o.tooLong ?? `is too long (maximum is ${o.maximum} characters)`,
+        { type: "length" },
+        record,
+        value
+      );
+      return;
+    }
+  }
+};
+var lengthOf = (value) => {
+  if (value == null) return 0;
+  if (typeof value === "string" || Array.isArray(value)) return value.length;
+  if (value instanceof Set || value instanceof Map) return value.size;
+  return String(value).length;
+};
+var FormatValidator = class {
+  constructor(attribute, options) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "format";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const value = reader(this.attribute)(record);
+    if (skipForNullable(value, this.options)) return;
+    const str = value == null ? "" : String(value);
+    if (this.options.with && !this.options.with.test(str)) {
+      recordError(this.options, errors, this.attribute, "is invalid", { type: "format" }, record, value);
+    }
+    if (this.options.without && this.options.without.test(str)) {
+      recordError(this.options, errors, this.attribute, "is invalid", { type: "format" }, record, value);
+    }
+  }
+};
+var InclusionValidator = class {
+  constructor(attribute, options) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "inclusion";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const value = reader(this.attribute)(record);
+    if (skipForNullable(value, this.options)) return;
+    if (!this.options.in.includes(value)) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        "is not included in the list",
+        { type: "inclusion" },
+        record,
+        value
+      );
+    }
+  }
+};
+var ExclusionValidator = class {
+  constructor(attribute, options) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "exclusion";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const value = reader(this.attribute)(record);
+    if (skipForNullable(value, this.options)) return;
+    if (this.options.in.includes(value)) {
+      recordError(this.options, errors, this.attribute, "is reserved", { type: "exclusion" }, record, value);
+    }
+  }
+};
+var NumericalityValidator = class {
+  constructor(attribute, options = {}) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "numericality";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const value = reader(this.attribute)(record);
+    if (skipForNullable(value, this.options)) return;
+    const num = Number(value);
+    if (Number.isNaN(num) || !Number.isFinite(num)) {
+      recordError(this.options, errors, this.attribute, "is not a number", { type: "numericality" }, record, value);
+      return;
+    }
+    const o = this.options;
+    if (o.onlyInteger && !Number.isInteger(num)) {
+      recordError(this.options, errors, this.attribute, "must be an integer", { type: "numericality.only_integer" });
+    }
+    if (o.greaterThan !== void 0 && !(num > o.greaterThan)) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        `must be greater than ${o.greaterThan}`,
+        { type: "numericality.greater_than" },
+        record,
+        value
+      );
+    }
+    if (o.greaterThanOrEqualTo !== void 0 && !(num >= o.greaterThanOrEqualTo)) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        `must be greater than or equal to ${o.greaterThanOrEqualTo}`,
+        { type: "numericality.greater_than_or_equal_to" },
+        record,
+        value
+      );
+    }
+    if (o.lessThan !== void 0 && !(num < o.lessThan)) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        `must be less than ${o.lessThan}`,
+        { type: "numericality.less_than" },
+        record,
+        value
+      );
+    }
+    if (o.lessThanOrEqualTo !== void 0 && !(num <= o.lessThanOrEqualTo)) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        `must be less than or equal to ${o.lessThanOrEqualTo}`,
+        { type: "numericality.less_than_or_equal_to" },
+        record,
+        value
+      );
+    }
+    if (o.equalTo !== void 0 && num !== o.equalTo) {
+      recordError(
+        this.options,
+        errors,
+        this.attribute,
+        `must be equal to ${o.equalTo}`,
+        { type: "numericality.equal_to" },
+        record,
+        value
+      );
+    }
+    if (o.odd && num % 2 === 0)
+      recordError(this.options, errors, this.attribute, "must be odd", { type: "numericality.odd" });
+    if (o.even && num % 2 !== 0)
+      recordError(this.options, errors, this.attribute, "must be even", { type: "numericality.even" });
+  }
+};
+var AcceptanceValidator = class {
+  constructor(attribute, options = {}) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "acceptance";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const accept = this.options.accept ?? [true, "1", 1];
+    const value = reader(this.attribute)(record);
+    if (!accept.includes(value)) {
+      recordError(this.options, errors, this.attribute, "must be accepted", { type: "acceptance" }, record, value);
+    }
+  }
+};
+var ConfirmationValidator = class {
+  constructor(attribute, options = {}) {
+    this.attribute = attribute;
+    this.options = options;
+    this.attributes = [attribute];
+  }
+  attribute;
+  options;
+  kind = "confirmation";
+  attributes;
+  validate(record, errors, context) {
+    if (!shouldValidate(record, this.options, context)) return;
+    const value = reader(this.attribute)(record);
+    const confirmation = reader(`${this.attribute}Confirmation`)(record);
+    if (confirmation === void 0) return;
+    const a = value == null ? "" : String(value);
+    const b = confirmation == null ? "" : String(confirmation);
+    const equal = this.options.caseSensitive === false ? a.toLowerCase() === b.toLowerCase() : a === b;
+    if (!equal) {
+      recordError(
+        this.options,
+        errors,
+        `${this.attribute}Confirmation`,
+        "doesn't match",
+        { type: "confirmation" },
+        record,
+        value
+      );
+    }
+  }
+};
+
+// src/Model.ts
+var ValidationError = class extends Error {
+  constructor(record) {
+    super(`Validation failed: ${record.errors.fullMessages.join(", ")}`);
+    this.record = record;
+  }
+  record;
+};
+var resolveType = (ref) => typeof ref === "string" ? lookupType(ref) : ref;
+var REGISTRY2 = /* @__PURE__ */ Symbol.for("@active-record-ts/active-model:registry");
+var getRegistry = (ctor) => {
+  const own = ctor[REGISTRY2];
+  if (own && Object.hasOwn(ctor, REGISTRY2)) return own;
+  const parent = Object.getPrototypeOf(ctor);
+  const parentReg = parent && parent !== Function.prototype ? getRegistry(parent) : null;
+  const fresh = {
+    attributeSet: parentReg ? parentReg.attributeSet.clone() : new AttributeSet(),
+    validators: parentReg ? [...parentReg.validators] : [],
+    callbacks: new CallbackChain()
+  };
+  if (parentReg) fresh.callbacks.inheritFrom(parentReg.callbacks);
+  Object.defineProperty(ctor, REGISTRY2, { value: fresh, enumerable: false, configurable: true, writable: false });
+  return fresh;
+};
+var camelizeSuffix = (name) => name.replace(/(?:^|[_-])([a-z0-9])/gi, (_, c) => c.toUpperCase()).replace(/[^A-Za-z0-9]/g, "");
+var definePerAttributeDirty = (target, names) => {
+  for (const name of names) {
+    const suffix = camelizeSuffix(name);
+    const camelName = lowerFirst(suffix);
+    const helpers = {
+      [`${camelName}Changed`]() {
+        return this.attributeChanged(name);
+      },
+      [`${camelName}Was`]() {
+        return this.attributeWas(name);
+      },
+      [`${camelName}Change`]() {
+        if (!this.attributeChanged(name)) return null;
+        return [this.attributeWas(name), this.readAttribute(name)];
+      },
+      [`restore${suffix}`]() {
+        this.writeAttribute(name, this.attributeWas(name));
+      },
+      [`${camelName}WillChange`]() {
+        this.willChange(name);
+      },
+      [`${camelName}PreviouslyChanged`]() {
+        return Object.hasOwn(this.savedChanges(), name);
+      },
+      [`${camelName}PreviousChange`]() {
+        const saved = this.savedChanges();
+        return Object.hasOwn(saved, name) ? saved[name] : null;
+      }
+    };
+    for (const [methodName, fn] of Object.entries(helpers)) {
+      if (Object.hasOwn(target.prototype, methodName)) continue;
+      Object.defineProperty(target.prototype, methodName, {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: fn
+      });
+    }
+  }
+};
+var lowerFirst = (s) => s.length === 0 ? s : s.charAt(0).toLowerCase() + s.slice(1);
+var defineAccessors = (target, names) => {
+  for (const name of names) {
+    if (Object.hasOwn(target.prototype, name)) continue;
+    let proto = Object.getPrototypeOf(target.prototype);
+    let inheritedAccessor = false;
+    while (proto) {
+      const desc = Object.getOwnPropertyDescriptor(proto, name);
+      if (desc && (desc.get || desc.set)) {
+        inheritedAccessor = true;
+        break;
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+    if (inheritedAccessor) continue;
+    Object.defineProperty(target.prototype, name, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return this.readAttribute(name);
+      },
+      set(value) {
+        this.writeAttribute(name, value);
+      }
+    });
+  }
+};
+var Model = class {
+  /** Per-instance attribute state, lazily initialized. */
+  _attributes;
+  /** Per-instance error collection. */
+  errors = new Errors();
+  // biome-ignore lint/complexity/noBannedTypes: constructor body sets up attributes uniformly
+  constructor(values = {}) {
+    const ctor = this.constructor;
+    const reg = getRegistry(ctor);
+    this._attributes = new Attributes(reg.attributeSet);
+    this._attributes.hydrateDefaults(values);
+    const names = reg.attributeSet.keys();
+    defineAccessors(ctor, names);
+    definePerAttributeDirty(ctor, names);
+    void reg.callbacks.run("initialize", this, async () => {
+    });
+  }
+  // ──────────────────────────── attribute IO ────────────────────────────
+  readAttribute(name) {
+    return this._attributes.read(name);
+  }
+  writeAttribute(name, value) {
+    this._attributes.write(name, value);
+  }
+  /** Plain object snapshot. */
+  attributes() {
+    return this._attributes.toHash();
+  }
+  assignAttributes(values) {
+    for (const [name, value] of Object.entries(values)) this.writeAttribute(name, value);
+    return this;
+  }
+  // ──────────────────────────── dirty tracking ────────────────────────────
+  changed() {
+    return this._attributes.changedAttributes();
+  }
+  changes() {
+    return this._attributes.changes();
+  }
+  attributeChanged(name) {
+    return this._attributes.changed(name);
+  }
+  attributeWas(name) {
+    return this._attributes.was(name);
+  }
+  savedChanges() {
+    return this._attributes.savedChanges();
+  }
+  /**
+   * Tell the dirty tracker that `name` is about to be mutated in place,
+   * so subsequent reads detect it as a change. Mirrors Rails'
+   * `name_will_change!`.
+   */
+  willChange(name) {
+    this._attributes.willChange(name);
+  }
+  /**
+   * Revert pending changes. With no argument restores every changed
+   * attribute; with `names` restores only the listed ones. Mirrors
+   * Rails' `restore_attributes(['name'])`.
+   */
+  restoreAttributes(names) {
+    if (!names) {
+      this._attributes.restore();
+      return;
+    }
+    for (const name of names) {
+      this._attributes.write(name, this._attributes.was(name));
+    }
+  }
+  /** Reset both pending and last-saved changes — Rails' `clear_changes_information`. */
+  clearChangesInformation() {
+    this._attributes.clearChanges();
+  }
+  // ──────────────────────────── validation ────────────────────────────
+  async validate(context) {
+    this.errors.clear();
+    const ctor = this.constructor;
+    const reg = getRegistry(ctor);
+    await reg.callbacks.run(
+      "validation",
+      this,
+      async () => {
+        for (const v of reg.validators) await v.validate(this, this.errors, context);
+      },
+      context
+    );
+    return this.errors.empty;
+  }
+  async isValid(context) {
+    return this.validate(context);
+  }
+  async isInvalid(context) {
+    return !await this.validate(context);
+  }
+  /** Mirrors Rails' `validate!`. Throws when invalid, returns true otherwise. */
+  async validateOrThrow(context) {
+    const ok = await this.validate(context);
+    if (!ok) throw new ValidationError(this);
+    return true;
+  }
+  // ──────────────────────────── helpers ────────────────────────────
+  toJSON(options = {}) {
+    const all = this.attributes();
+    if (options.only) {
+      const out = {};
+      for (const name of options.only) if (name in all) out[name] = all[name];
+      return out;
+    }
+    if (options.except) {
+      const out = {};
+      const exclude = new Set(options.except);
+      for (const [name, value] of Object.entries(all)) if (!exclude.has(name)) out[name] = value;
+      return out;
+    }
+    return all;
+  }
+  /**
+   * Return a new instance of the same class with the same attribute
+   * values. Mirrors Rails' `record.dup`. The AR layer overrides this
+   * to also clear the primary key so the duplicate looks like a fresh
+   * (unsaved) record.
+   */
+  dup() {
+    const ctor = this.constructor;
+    const copy = new ctor();
+    copy._attributes.hydrate(this.attributes());
+    return copy;
+  }
+  // ──────────────────────────── class-side configuration ────────────────────────────
+  /** Register an attribute on this subclass. Returns the constructor for chaining. */
+  static attribute(name, type, options) {
+    const reg = getRegistry(this);
+    reg.attributeSet.define({ name, type: resolveType(type), default: options?.default });
+    defineAccessors(this, [name]);
+    definePerAttributeDirty(this, [name]);
+    return this;
+  }
+  /** Access the per-class `AttributeSet`. */
+  static attributesSchema() {
+    return getRegistry(this).attributeSet;
+  }
+  /** Register a validator instance. */
+  static validatesWith(validator) {
+    getRegistry(this).validators.push(validator);
+    return this;
+  }
+  /**
+   * Register a free-form block validator — `Klass.validate((record, errors) => ...)`.
+   * The function may be async and receives the same `(record, errors, context)`
+   * arguments every built-in validator does.
+   */
+  static validate(fn, options = {}) {
+    return this.validatesWith(new BlockValidator(fn, options));
+  }
+  /** All registered validators in declaration order (inherited + own). */
+  static validators() {
+    return getRegistry(this).validators;
+  }
+  /** Validators that target any of the given attribute names. */
+  static validatorsOn(...attributes) {
+    const wanted = new Set(attributes);
+    return this.validators().filter((v) => {
+      const attrs = v.attributes;
+      if (!attrs) return false;
+      for (const a of attrs) if (wanted.has(a)) return true;
+      return false;
+    });
+  }
+  /** Reset all per-class validators. Rails' `clear_validators!`. */
+  static clearValidators() {
+    getRegistry(this).validators.length = 0;
+    return this;
+  }
+  /**
+   * Run a function once per attribute, accumulating errors. Mirrors Rails'
+   * `validates_each :a, :b do |record, attr, value| ... end`.
+   *
+   *   Klass.validatesEach(['a', 'b'], (record, attr, value, errors) => {
+   *     if (!ok(value)) errors.add(attr, 'bad');
+   *   });
+   */
+  static validatesEach(attributes, fn, options = {}) {
+    return this.validate(async (record, errors) => {
+      for (const attr of attributes) {
+        const value = record[attr];
+        await fn(record, attr, value, errors);
+      }
+    }, options);
+  }
+  /** Add a presence validator. */
+  static validatesPresenceOf(attribute, options = {}) {
+    return this.validatesWith(new PresenceValidator(attribute, options));
+  }
+  static validatesAbsenceOf(attribute, options = {}) {
+    return this.validatesWith(new AbsenceValidator(attribute, options));
+  }
+  static validatesLengthOf(attribute, options) {
+    return this.validatesWith(new LengthValidator(attribute, options));
+  }
+  static validatesFormatOf(attribute, options) {
+    return this.validatesWith(new FormatValidator(attribute, options));
+  }
+  static validatesInclusionOf(attribute, options) {
+    return this.validatesWith(new InclusionValidator(attribute, options));
+  }
+  static validatesExclusionOf(attribute, options) {
+    return this.validatesWith(new ExclusionValidator(attribute, options));
+  }
+  static validatesNumericalityOf(attribute, options = {}) {
+    return this.validatesWith(new NumericalityValidator(attribute, options));
+  }
+  static validatesAcceptanceOf(attribute, options = {}) {
+    return this.validatesWith(new AcceptanceValidator(attribute, options));
+  }
+  static validatesConfirmationOf(attribute, options = {}) {
+    return this.validatesWith(new ConfirmationValidator(attribute, options));
+  }
+  /**
+   * Sugar mirroring Rails' `validates :name, presence: true, length: { minimum: 2 }`.
+   */
+  static validates(attribute, rules) {
+    if (rules.presence) this.validatesPresenceOf(attribute, rules.presence === true ? {} : rules.presence);
+    if (rules.absence) this.validatesAbsenceOf(attribute, rules.absence === true ? {} : rules.absence);
+    if (rules.length) this.validatesLengthOf(attribute, rules.length);
+    if (rules.format) this.validatesFormatOf(attribute, rules.format);
+    if (rules.inclusion) this.validatesInclusionOf(attribute, rules.inclusion);
+    if (rules.exclusion) this.validatesExclusionOf(attribute, rules.exclusion);
+    if (rules.numericality)
+      this.validatesNumericalityOf(attribute, rules.numericality === true ? {} : rules.numericality);
+    if (rules.acceptance) this.validatesAcceptanceOf(attribute, rules.acceptance === true ? {} : rules.acceptance);
+    if (rules.confirmation)
+      this.validatesConfirmationOf(attribute, rules.confirmation === true ? {} : rules.confirmation);
+    return this;
+  }
+  // ──────────────────────────── callbacks ────────────────────────────
+  /** Options that can be passed to any callback registration helper. */
+  static setCallback(event, kind, fn, options) {
+    getRegistry(this).callbacks.add(event, kind, fn, options);
+    return this;
+  }
+  static beforeValidation(fn, options) {
+    return this.setCallback("validation", "before", fn, options);
+  }
+  static afterValidation(fn, options) {
+    return this.setCallback("validation", "after", fn, options);
+  }
+  static beforeSave(fn) {
+    return this.setCallback("save", "before", fn);
+  }
+  static afterSave(fn) {
+    return this.setCallback("save", "after", fn);
+  }
+  static aroundSave(fn) {
+    return this.setCallback("save", "around", fn);
+  }
+  static beforeCreate(...fns) {
+    for (const fn of fns) this.setCallback("create", "before", fn);
+    return this;
+  }
+  static afterCreate(...fns) {
+    for (const fn of fns) this.setCallback("create", "after", fn);
+    return this;
+  }
+  static beforeUpdate(fn) {
+    return this.setCallback("update", "before", fn);
+  }
+  static afterUpdate(fn) {
+    return this.setCallback("update", "after", fn);
+  }
+  static beforeDestroy(fn) {
+    return this.setCallback("destroy", "before", fn);
+  }
+  static afterDestroy(fn) {
+    return this.setCallback("destroy", "after", fn);
+  }
+  /**
+   * Run `fn` after the outermost transaction surrounding this record's
+   * save / destroy commits. When the record is touched outside a
+   * transaction, the callback fires immediately after the save.
+   */
+  static afterCommit(fn, options) {
+    return this.setCallback("commit", "after", fn, options);
+  }
+  /** Run `fn` when the surrounding transaction rolls back. */
+  static afterRollback(fn, options) {
+    return this.setCallback("rollback", "after", fn, options);
+  }
+  /** Run `fn` whenever a new instance is constructed. */
+  static afterInitialize(fn) {
+    return this.setCallback("initialize", "after", fn);
+  }
+  /** Run `fn` when a record is hydrated from the database. */
+  static afterFind(fn) {
+    return this.setCallback("find", "after", fn);
+  }
+  /** Run `fn` after `touch()`. */
+  static afterTouch(fn) {
+    return this.setCallback("touch", "after", fn);
+  }
+  /** Run a registered callback chain — typically used by ActiveRecord persistence. */
+  static async runCallbacks(event, record, body, context) {
+    return getRegistry(this).callbacks.run(event, record, body, context);
+  }
+};
+
+// src/inflector.ts
+var IRREGULAR = [
+  ["person", "people"],
+  ["man", "men"],
+  ["woman", "women"],
+  ["child", "children"],
+  ["ox", "oxen"],
+  ["mouse", "mice"],
+  ["octopus", "octopi"],
+  ["cactus", "cacti"],
+  ["goose", "geese"],
+  ["foot", "feet"],
+  ["tooth", "teeth"]
+];
+var UNCOUNTABLE = /* @__PURE__ */ new Set(["equipment", "information", "rice", "money", "species", "series", "fish", "sheep"]);
+var PLURAL_RULES = [
+  [/(quiz)$/i, "$1zes"],
+  [/^(ox)$/i, "$1en"],
+  [/([m|l])ouse$/i, "$1ice"],
+  [/(matr|vert|ind)ix|ex$/i, "$1ices"],
+  [/(x|ch|ss|sh)$/i, "$1es"],
+  [/([^aeiouy]|qu)y$/i, "$1ies"],
+  [/(hive)$/i, "$1s"],
+  [/(?:([^f])fe|([lr])f)$/i, "$1$2ves"],
+  [/sis$/i, "ses"],
+  [/([ti])um$/i, "$1a"],
+  [/(buffal|tomat)o$/i, "$1oes"],
+  [/(bu)s$/i, "$1ses"],
+  [/(alias|status)$/i, "$1es"],
+  [/(octop|vir)us$/i, "$1i"],
+  [/(ax|test)is$/i, "$1es"],
+  [/s$/i, "s"],
+  [/$/, "s"]
+];
+var pluralize = (word) => {
+  if (!word) return word;
+  const lower = word.toLowerCase();
+  if (UNCOUNTABLE.has(lower)) return word;
+  for (const [singular, plural] of IRREGULAR) {
+    if (lower === singular) return plural;
+    if (lower === plural) return plural;
+  }
+  for (const [pattern, replacement] of PLURAL_RULES) {
+    if (pattern.test(word)) return word.replace(pattern, replacement);
+  }
+  return `${word}s`;
+};
+var underscore = (word) => word.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/-/g, "_").toLowerCase();
+var camelize = (word, lower = false) => {
+  const camel = word.split(/[_-]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  return lower ? camel.charAt(0).toLowerCase() + camel.slice(1) : camel;
+};
+var tableize = (className) => pluralize(underscore(className));
+
+// src/Name.ts
+var UNCOUNTABLE2 = /* @__PURE__ */ new Set(["equipment", "information", "rice", "money", "species", "series", "fish", "sheep"]);
+var humanize2 = (word) => {
+  const spaced = word.replace(/_/g, " ").toLowerCase();
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+};
+var Name = class {
+  /** The class itself (or its name, when called with a class-name string). */
+  klass;
+  /** The fully-qualified class name as written. */
+  name;
+  /** Snake-case version of the (possibly namespaced) class name. e.g. `Post::TrackBack` -> `post_track_back`. */
+  singular;
+  /** Plural form of `singular`. e.g. `post_track_back` -> `post_track_backs`. */
+  plural;
+  /** Last segment, snake-cased. e.g. `Post::TrackBack` -> `track_back`. */
+  element;
+  /** Forward-slash-joined collection name. e.g. `Post::TrackBack` -> `post/track_backs`. */
+  collection;
+  /** Rails routing helper — plural element with optional namespace prefix. */
+  route_key;
+  /** `singular` minus internal namespace separators. */
+  param_key;
+  /** Slash-joined namespace key. e.g. `Post::TrackBack` -> `post/track_back`. */
+  i18n_key;
+  /** Human-friendly element name. e.g. `track_back` -> `Track back`. */
+  human;
+  /**
+   * Build a `Name` from a class (uses `klass.name`) or directly from a
+   * Ruby-style namespaced string ("Post::TrackBack").
+   */
+  constructor(klassOrName) {
+    this.klass = typeof klassOrName === "string" ? { name: klassOrName } : klassOrName;
+    this.name = this.klass.name;
+    const parts = this.name.split("::");
+    const last = parts[parts.length - 1];
+    const nsParts = parts.slice(0, -1).map((p) => underscore(p));
+    const lastSnake = underscore(last);
+    this.singular = [...nsParts, lastSnake].join("_");
+    this.plural = pluralize(this.singular);
+    this.element = lastSnake;
+    const elementPlural = pluralize(lastSnake);
+    this.collection = nsParts.length === 0 ? elementPlural : `${nsParts.join("/")}/${elementPlural}`;
+    this.route_key = nsParts.length === 0 ? elementPlural : `${nsParts.join("_")}_${elementPlural}`;
+    this.param_key = this.singular;
+    this.i18n_key = nsParts.length === 0 ? lastSnake : `${nsParts.join("/")}/${lastSnake}`;
+    this.human = humanize2(lastSnake);
+  }
+  /** Whether the singular form is uncountable (plural === singular). */
+  get uncountable() {
+    return UNCOUNTABLE2.has(this.singular.toLowerCase());
+  }
+  toString() {
+    return this.name;
+  }
+};
+export {
+  ABORT_SENTINEL,
+  AbsenceValidator,
+  AcceptanceValidator,
+  AttributeSet,
+  Attributes,
+  BASE,
+  BigIntType,
+  BinaryType,
+  BooleanType,
+  CallbackChain,
+  ConfirmationValidator,
+  DateTimeType,
+  DateType,
+  DecimalType,
+  ErrorObject,
+  Errors,
+  ExclusionValidator,
+  FloatType,
+  FormatValidator,
+  HaltError,
+  InclusionValidator,
+  IntegerType,
+  JSONType,
+  LengthValidator,
+  Model,
+  Name,
+  NumericalityValidator,
+  PresenceValidator,
+  StrictValidationFailed,
+  StringType,
+  ValidationError,
+  ValueType,
+  camelize,
+  hasType,
+  lookupType,
+  pluralize,
+  registerType,
+  tableize,
+  throwAbort,
+  underscore,
+  valuesEqual
+};
+//# sourceMappingURL=index.js.map