In `@packages/core/src/abstract-dialect/query-generator.js`:
- Around line 1495-1506: The ORDER BY direction from options.order is used
directly when building orderClauses; validate the direction against
VALID_ORDER_OPTIONS before interpolating to avoid unexpected SQL. In the order
mapping logic (where orders, orderClauses, and the tuple [col, dir] are
handled), normalize dir to a canonical form (e.g., toUpperCase()), check
inclusion in VALID_ORDER_OPTIONS, and if invalid either throw a clear error or
fall back to a safe default like 'ASC'; then use the validated value when
calling quoteIdentifier(col) and building the clause. Ensure VALID_ORDER_OPTIONS
is referenced and used for validation so behavior matches the rest of the
codebase.
- Around line 1509-1514: The conditional that decides whether to call
this.#internals.addLimitAndOffset uses a truthy check (if (options.limit ||
options.offset)) — change it to use explicit null/undefined checks to match the
file's pattern by testing options.limit != null || options.offset != null so
LIMIT/OFFSET with zero values are handled consistently; update the conditional
near the query assembly where query and limitOrder are used (the block calling
this.#internals.addLimitAndOffset with options.limit/options.offset).

In `@packages/core/src/abstract-dialect/query-interface.js`:
- Around line 585-588: Before calling this.sequelize.queryRaw in the union flow,
remove options.replacements the same way select() does to avoid double
replacements: obtain or clone the options passed to unionQuery (referencing
this.queryGenerator.unionQuery and the local variable options), delete the
replacements property (options.replacements) on that cloned options object, then
pass the sanitized options into this.sequelize.queryRaw(sql, sanitizedOptions).
Ensure you do not mutate the original options object if other callers rely on
it.
- Around line 583-584: The merge currently allows callers to override the query
type; in the async union(sqls, options) function ensure QueryTypes.SELECT is
applied after merging so callers cannot override it. Modify the options
assignment to first merge user options (e.g., options = { ...options }) and then
enforce options.type = QueryTypes.SELECT (or recreate options = { ...options,
type: QueryTypes.SELECT }) so the function always uses SELECT; update references
to options in union accordingly.

In `@packages/core/src/sequelize.js`:
- Around line 247-252: In union, add upfront validation to ensure the queries
array is not empty and each entry has a valid model: check that queries is an
array with length > 0 and iterate queries to verify q && q.model is present (and
optionally that q.options exists); throw a clear TypeError or return a rejected
Promise with a descriptive message if validation fails. Place this check at the
start of the async union(queries, options = {}) method before mapping queries so
that later uses of q.model and q.options (e.g., the mapping that references
q.model and q.options) are safe and produce deterministic errors.
- Line 287: Update the UnionOptions type so it includes transaction support by
extending QueryRawOptions instead of only AddLimitOffsetOptions: find the
UnionOptions type (used by the union method) and change its extends clause to
include QueryRawOptions (which includes Transactionable) so callers can pass a
transaction through the union() call that ultimately delegates to queryRaw;
ensure any existing properties (limit, offset, replacements) remain present and
compatible with QueryRawOptions.

In `@packages/core/test/integration/sequelize/union.test.ts`:
- Line 41: The tests cast sequelize to any because the custom union method is
missing from the Sequelize type definitions; add a TypeScript declaration for
the union method (its signature used in tests) and surface it via module
augmentation or by extending the Sequelize interface so the test instance has
the correct type instead of casting. Concretely, add a declaration file (or
update the package's exported types) that augments the 'sequelize' module /
Sequelize class with union(params: Array<{ model: typeof Model }>):
Promise<any[]> (match the real return type), export that types file from the
package (or include it in the package's types entry), then remove the (sequelize
as any) casts in union.test.ts so the test uses the updated typed
sequelize.union method.
- Around line 96-109: Test currently asserts that 'age' is absent but doesn't
assert whether the primary key was injected when attributes were specified;
update the test for sequelize.union to also assert presence (or absence, as
appropriate) of the injected primary key field (id) when calling (sequelize as
any).union with options { attributes: ['name'] } and raw mode not set, e.g.,
after creating vars.User and vars.Guest check results include the primary key
property 'id' (or verify deduplication behavior relies on id) so the behavior of
attribute injection in the union implementation (union, attributes, raw, id,
vars.User, vars.Guest) is covered.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@packages/core/src/abstract-dialect/query-generator.js`:
- Around line 1487-1522: The unionQuery method should not use options.unionAll
unconditionally; update the join character selection in unionQuery to check the
dialect capability by using this.dialect.supports['UNION ALL'] &&
options.unionAll to decide between ' UNION ALL ' and ' UNION '; change the
existing joinChar assignment accordingly (referencing unionQuery,
options.unionAll, and this.dialect.supports['UNION ALL']) and ensure tests/usage
that passed options.unionAll on dialects without support still produce plain
UNION (or add a dialect-specific override for unionQuery where necessary, e.g.,
MSSQL).
- Around line 1514-1519: The code appends an extra leading space before the
LIMIT/OFFSET clause because addLimitAndOffset already returns a leading-space
string; in the block that computes limitOrder (the if checking
options.limit/options.offset) replace the template literal that prepends " "
(query += ` ${limitOrder}`) with a direct append (query += limitOrder) or trim
the leading space from limitOrder so the generated SQL has only a single space
before the clause; refer to the addLimitAndOffset call and the limitOrder
variable when making the change.

In `@packages/core/src/sequelize.js`:
- Around line 272-273: Remove the dead variable assignment: the tableNames
object (declared as tableNames and assigned tableNames[model.table] = true) is
never read later; delete the tableNames declaration and the assignment to
tableNames[model.table] so only the actual logic remains (this was likely copied
from a Model.findAll pattern and is unnecessary here), leaving all references to
model and its properties intact.

---

Duplicate comments:
In `@packages/core/src/abstract-dialect/query-generator.js`:
- Around line 1498-1509: The code silently normalizes an invalid order direction
to 'ASC' in the Array.isArray(t) branch; instead, validate the direction against
VALID_ORDER_OPTIONS and throw a descriptive error when it's not recognized. In
the Array tuple handling (where you destructure const [col, dir] and compute
normalizedDir), replace the fallback normalization with a check that if dir is a
string but not included in VALID_ORDER_OPTIONS you throw (e.g., Error or
TypeError) naming the invalid direction and listing VALID_ORDER_OPTIONS; if dir
is undefined use the default 'ASC' as before, and continue to use
this.quoteIdentifier(col) for the column in the returned string.

---

Nitpick comments:
In `@packages/core/test/integration/sequelize/union.test.ts`:
- Line 5: Replace the hardcoded describe title with the dialect teaser helper:
change the describe('Sequelize#union', ...) call to use
Support.getTestDialectTeaser('Sequelize#union') so the test description is
dialect-aware (locate the describe call in union.test.ts and update it to call
Support.getTestDialectTeaser).
- Around line 59-67: The deduplication assertion in the "supports UNION
(deduplicates by default)" test is brittle because it relies on matching
auto-increment IDs from vars.User and vars.Guest; update the test to make the
UNION compare only business fields by calling sequelize.union with sub-selects
that exclude the id (e.g., provide attributes: ['name','age'] for each entry) or
pass raw: true so the result rows lack the id, then assert deduplication on
name/age; locate the call to sequelize.union and the vars.User/vars.Guest
creates in that test and change the union invocation to use attributes or raw as
described.