UDDTs / scalar alias types (CREATE TYPE name FROM <builtin> [NULL|NOT NULL]) — second bacpac prerequisite. Real-feature implementation, not loader-only inline expansion. New AliasType class + Schema.AliasTypes ConcurrentDictionary sharing the type-name namespace with TableTypes (Msg 219 spans both dicts). Simulation.CreateType.cs gains a top-level AS-vs-FROM dispatch after the type name; the FROM branch reads the base type (length / scale via the standard (N[, S]) form), the optional NULL / NOT NULL marker (bare / explicit NULL both → nullable; NOT NULL → non-nullable, probe-confirmed against SQL Server 2025 on 2026-05-14), and stores into Schema.AliasTypes. Unknown base type raises Msg 222 verbatim (The base type "X" is not a valid base type for the alias data type.); namespace collision raises Msg 219.

Multi-part type-reference parsing extends every consumer site — CREATE TABLE column, DECLARE @v, ALTER TABLE ALTER COLUMN, CREATE PROCEDURE / FUNCTION / SEQUENCE parameter, OPENJSON column, sp_executesql parameter — to accept 1- or 2-part dotted names (`[dbo].[AccountNumber]`). Each site routes through the new `Simulation.ResolveTypeReference(BatchContext, MultiPartName, Name leaf, …)` helper which checks `Schema.AliasTypes` first and falls back to `SqlType.GetByName` for built-ins. Length specifier at an alias-usage site raises Msg 2716 St 3 verbatim with the alias's fully-qualified name (probe-confirmed: real SQL Server uses State 3 for the alias variant, distinct from State 1 used by built-ins; new factory `CannotSpecifyColumnWidthOnAlias` sits alongside the existing `CannotSpecifyColumnWidth`).

Nullability inheritance ships at the column-declaration sites (CREATE TABLE column, ALTER TABLE ALTER COLUMN): when the column references an alias and has no explicit `NULL` / `NOT NULL` of its own, the alias's stored `IsNullable` propagates as the default. An explicit column-side marker always wins. ALTER COLUMN's precedence chain is: explicit marker → alias default → preserve existing column nullability.

DECLARE @v with a 2-part alias-typed reference falls through from the table-type binding path to the scalar parser when `TryResolveAliasType` matches (cursor restored via checkpoint). DROP TYPE handles both dicts: alias drops remove from `Schema.AliasTypes` (Msg 218 on missing without IF EXISTS; IF EXISTS no-ops a miss); the existing table-type branch including Msg 3732 enforcement is untouched. `sys.types` augmented with alias rows via `EnumerateSysTypes`: `system_type_id` from the underlying built-in (e.g. 56 for int-of-…, 231 for nvarchar-of-…), `user_type_id` from the alias's per-database allocation, `schema_id` from the owning schema, `is_user_defined=1`, `is_table_type=0`, `is_nullable` from the alias's stored marker.

18 new tests in `AliasTypeTests.cs` cover: 4 nullability shapes (NOT NULL inheritance, bare = nullable, explicit NULL = nullable, column-NULL overrides alias-NOT-NULL), unqualified + bracketed-qualified column references, Msg 2716 / 222 / 219 / 218 paths, DROP TYPE happy + missing + IF EXISTS, sys.types row content for both NOT-NULL and bare aliases, DECLARE @v with alias, cross-schema (HR.EmployeeId), and a full AW-style 6-alias smoke test that declares AccountNumber / Flag / Name / NameStyle / OrderNumber / Phone and verifies `is_nullable=0` propagation for the three NOT-NULL aliases on a Customer table. Full suite 4622 → 4640, all green Debug + Release.

`docs/claude/bacpac-prerequisites.md` flips the UDDT bullet from `[ ]` to `[x]` with implementation detail and renumbers the order-of-operations sequence (Extended properties is now next). CLAUDE.md gains a sibling Feature-reference index entry next to the existing `CREATE TYPE … AS TABLE` one pointing back to the bacpac-prerequisites doc for the UDDT implementation detail. Two known fidelity gaps explicitly documented + deferred (not load-bearing for the bacpac baseline): `HeapColumn` doesn't retain a back-pointer to its declaring `AliasType` (so `sys.columns.user_type_id` surfaces the underlying built-in's id and `DROP TYPE` on alias doesn't enforce Msg 3732), and `sys.types.max_length` isn't emitted in the catalog view's shipped subset (pre-existing gap from before this bundle).

Author: RyanLamansky

CLAUDE.md

@@ -147,6 +147,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **Touching `#foo` routing, DROP TABLE, TRUNCATE TABLE** → [`docs/claude/temp-tables.md`](docs/claude/temp-tables.md).
 - **Touching `DECLARE @t TABLE`, table-variable DML routing, `OUTPUT … INTO <target>` (`@t` or regular)** → [`docs/claude/table-variables.md`](docs/claude/table-variables.md).
 - **Touching `CREATE TYPE … AS TABLE`, `DECLARE @t MyType`, TVP procedure parameters / `READONLY`, or the ADO.NET `DbParameter.TypeName` extension (DataTable / IDataReader as a TVP value source)** → [`docs/claude/table-valued-parameters.md`](docs/claude/table-valued-parameters.md).
+- **Touching `CREATE TYPE name FROM <builtin> [NULL|NOT NULL]` (scalar alias types / UDDTs), `Schema.AliasTypes` dict, multi-part type-reference parsing (`[schema].[typename]` in column / parameter / `DECLARE @v` / `ALTER COLUMN` / OPENJSON / sp_executesql positions), the `Simulation.ResolveTypeReference` helper, nullability inheritance from the alias default, Msg 222 / 2716 St 3 / 219 enforcement, or `sys.types` alias-type rows** → [`docs/claude/bacpac-prerequisites.md`](docs/claude/bacpac-prerequisites.md) (the section "UDDTs / alias types" carries the implementation detail; this is one of the bacpac-loader prerequisite bundles).
 - **Touching `CREATE SEQUENCE` / `ALTER SEQUENCE` / `DROP SEQUENCE`, `NEXT VALUE FOR`, the per-row dedup mechanism (`BatchContext.CurrentRowStamp` / `SequenceRowCache`), or `sys.sequences`** → [`docs/claude/sequences.md`](docs/claude/sequences.md).
 - **Touching `CREATE TRIGGER` / `ALTER TRIGGER` / `DROP TRIGGER` / `DISABLE`/`ENABLE TRIGGER`, the `INSERTED` / `DELETED` pseudo-table materialization, the `TriggerFrame` / `FiringTriggerIds` recursion guard, `TRIGGER_NESTLEVEL()`, or `sys.triggers`** → [`docs/claude/triggers.md`](docs/claude/triggers.md).
 - **Touching `FOREIGN KEY` parsing (`REFERENCES` inline / `FOREIGN KEY (cols) REFERENCES other(cols)` table-level), referential-action wiring (`ON DELETE` / `ON UPDATE` × `NO ACTION` / `CASCADE` / `SET NULL` / `SET DEFAULT`), the FK enforcement loop in `Simulation.ForeignKeys.cs`, the `HeapTable.OutgoingForeignKeys` / `IncomingForeignKeys` lists, cascade-cycle detection (Msg 1785), DROP-TABLE protection (Msg 3726), or `sys.foreign_keys` / `sys.foreign_key_columns`** → [`docs/claude/foreign-keys.md`](docs/claude/foreign-keys.md).

SqlServerSimulator.Tests/AliasTypeTests.cs

@@ -0,0 +1,230 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Exercises scalar user-defined alias types (UDDTs) created via
+/// <c>CREATE TYPE schema.name FROM &lt;builtin&gt;[(N[, S])] [NULL | NOT NULL]</c>.
+/// Alias types are the second bacpac prerequisite (after the database-options
+/// expansion); AdventureWorks2025 declares 6 of them (<c>AccountNumber</c>,
+/// <c>Flag</c>, <c>Name</c>, <c>NameStyle</c>, <c>OrderNumber</c>,
+/// <c>Phone</c>). Behavior probed against SQL Server 2025 (2026-05-14).
+/// </summary>
+[TestClass]
+public class AliasTypeTests
+{
+    [TestMethod]
+    public void CreateAlias_NotNull_Then_ColumnInheritsNotNullByDefault()
+    {
+        // Probe-confirmed: column with no explicit nullability marker inherits
+        // NOT NULL from the alias.
+        var ex = new Simulation().AssertSqlError("""
+            CREATE TYPE dbo.AccountNumber FROM nvarchar(15) NOT NULL;
+            CREATE TABLE t (c dbo.AccountNumber);
+            INSERT INTO t (c) VALUES (NULL);
+            """, 515);
+        Contains("does not allow nulls", ex.Message);
+    }
+
+    /// <summary>
+    /// Bare CREATE TYPE (no NULL/NOT NULL marker) → alias is nullable; the
+    /// column declaration without its own marker stays nullable.
+    /// </summary>
+    [TestMethod]
+    public void CreateAlias_Bare_ColumnIsNullable()
+        => AreEqual(1, new Simulation().ExecuteScalar("""
+            CREATE TYPE dbo.Probe FROM int;
+            CREATE TABLE t (c dbo.Probe);
+            INSERT INTO t (c) VALUES (NULL);
+            SELECT COUNT(*) FROM t WHERE c IS NULL
+            """));
+
+    [TestMethod]
+    public void CreateAlias_ExplicitNullKeyword_AliasIsNullable()
+        => AreEqual(1, new Simulation().ExecuteScalar("""
+            CREATE TYPE dbo.Probe FROM int NULL;
+            CREATE TABLE t (c dbo.Probe);
+            INSERT INTO t (c) VALUES (NULL);
+            SELECT COUNT(*) FROM t WHERE c IS NULL
+            """));
+
+    /// <summary>
+    /// Column-level explicit NULL overrides alias-defined NOT NULL — probe-
+    /// confirmed (real SQL Server treats the column-side marker as
+    /// authoritative when present).
+    /// </summary>
+    [TestMethod]
+    public void ColumnNullOverride_TrumpsAliasNotNull()
+        => AreEqual(1, new Simulation().ExecuteScalar("""
+            CREATE TYPE dbo.Tight FROM int NOT NULL;
+            CREATE TABLE t (c dbo.Tight NULL);
+            INSERT INTO t (c) VALUES (NULL);
+            SELECT COUNT(*) FROM t WHERE c IS NULL
+            """));
+
+    /// <summary>
+    /// Probe-confirmed: alias can be referenced without the schema qualifier
+    /// when it's in dbo (the default schema).
+    /// </summary>
+    [TestMethod]
+    public void UnqualifiedReference_Works()
+        => AreEqual(42, new Simulation().ExecuteScalar("""
+            CREATE TYPE dbo.Probe FROM int;
+            CREATE TABLE t (c Probe);
+            INSERT INTO t (c) VALUES (42);
+            SELECT c FROM t
+            """));
+
+    [TestMethod]
+    public void QualifiedReference_Works()
+        => AreEqual(42, new Simulation().ExecuteScalar("""
+            CREATE TYPE dbo.Probe FROM int;
+            CREATE TABLE t (c [dbo].[Probe]);
+            INSERT INTO t (c) VALUES (42);
+            SELECT c FROM t
+            """));
+
+    [TestMethod]
+    public void LengthAtUsageSite_RaisesMsg2716()
+    {
+        // Probe-confirmed verbatim: Msg 2716 St 3 with the alias's fully-
+        // qualified name in the message.
+        var ex = new Simulation().AssertSqlError("""
+            CREATE TYPE dbo.Name FROM nvarchar(50) NOT NULL;
+            CREATE TABLE t (c dbo.Name(100));
+            """, 2716);
+        Contains("dbo.Name", ex.Message);
+        Contains("Cannot specify a column width", ex.Message);
+    }
+
+    [TestMethod]
+    public void DuplicateTypeName_RaisesMsg219()
+    {
+        var ex = new Simulation().AssertSqlError("""
+            CREATE TYPE dbo.Probe FROM int;
+            CREATE TYPE dbo.Probe FROM int;
+            """, 219);
+        Contains("dbo.Probe", ex.Message);
+    }
+
+    [TestMethod]
+    public void AliasName_CollidesWithTableType_RaisesMsg219()
+    {
+        // Alias + table types share one type-name namespace.
+        var ex = new Simulation().AssertSqlError("""
+            CREATE TYPE dbo.Shared AS TABLE (id int);
+            CREATE TYPE dbo.Shared FROM int;
+            """, 219);
+        Contains("dbo.Shared", ex.Message);
+    }
+
+    [TestMethod]
+    public void InvalidBaseType_RaisesMsg222()
+    {
+        var ex = new Simulation().AssertSqlError(
+            "CREATE TYPE dbo.Bogus FROM not_a_type",
+            222);
+        Contains("not_a_type", ex.Message);
+        Contains("not a valid base type", ex.Message);
+    }
+
+    [TestMethod]
+    public void DropType_OnAlias_Removes()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("CREATE TYPE dbo.Probe FROM int");
+        AreEqual(1, sim.ExecuteScalar(
+            "SELECT COUNT(*) FROM sys.types WHERE name = 'Probe' AND is_user_defined = 1"));
+        _ = sim.ExecuteNonQuery("DROP TYPE dbo.Probe");
+        AreEqual(0, sim.ExecuteScalar(
+            "SELECT COUNT(*) FROM sys.types WHERE name = 'Probe' AND is_user_defined = 1"));
+    }
+
+    [TestMethod]
+    public void DropType_OnMissingAlias_RaisesMsg218()
+    {
+        _ = new Simulation().AssertSqlError("DROP TYPE dbo.NoSuchAlias", 218);
+    }
+
+    [TestMethod]
+    public void DropType_IfExists_OnMissingAlias_Succeeds()
+        => AreEqual(-1, new Simulation().ExecuteNonQuery("DROP TYPE IF EXISTS dbo.NoSuchAlias"));
+
+    [TestMethod]
+    public void SysTypes_Row_ShipsCorrectShape()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("CREATE TYPE dbo.AccountNumber FROM nvarchar(15) NOT NULL");
+        using var conn = sim.CreateOpenConnection();
+        using var cmd = conn.CreateCommand(
+            "SELECT system_type_id, is_user_defined, is_table_type, is_nullable FROM sys.types WHERE name = 'AccountNumber'");
+        using var reader = cmd.ExecuteReader();
+        IsTrue(reader.Read());
+        // nvarchar's system_type_id is 231 per probe.
+        AreEqual((byte)231, reader.GetByte(0));
+        IsTrue(reader.GetBoolean(1));   // is_user_defined
+        IsFalse(reader.GetBoolean(2));  // is_table_type
+        IsFalse(reader.GetBoolean(3));  // is_nullable (alias was NOT NULL)
+    }
+
+    [TestMethod]
+    public void SysTypes_BareAlias_IsNullable()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("CREATE TYPE dbo.Probe FROM int");
+        IsTrue((bool)sim.ExecuteScalar(
+            "SELECT is_nullable FROM sys.types WHERE name = 'Probe'")!);
+    }
+
+    [TestMethod]
+    public void Declare_AliasTypedVariable_Works()
+        => AreEqual(42, new Simulation().ExecuteScalar("""
+            CREATE TYPE dbo.Probe FROM int;
+            DECLARE @v dbo.Probe;
+            SET @v = 42;
+            SELECT @v
+            """));
+
+    [TestMethod]
+    public void AdventureWorksAliasTypes_LoadSuccessfully()
+    {
+        // Smoke test for the AW alias-type set — all six should be declarable
+        // and usable as column types end-to-end.
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            CREATE TYPE dbo.AccountNumber FROM nvarchar(15) NOT NULL;
+            CREATE TYPE dbo.Flag FROM bit NOT NULL;
+            CREATE TYPE dbo.Name FROM nvarchar(50) NOT NULL;
+            CREATE TYPE dbo.NameStyle FROM bit NOT NULL;
+            CREATE TYPE dbo.OrderNumber FROM nvarchar(25) NOT NULL;
+            CREATE TYPE dbo.Phone FROM nvarchar(25);
+            CREATE TABLE dbo.Customer (
+                AccountNumber [dbo].[AccountNumber],
+                Title [dbo].[Name],
+                NameStyle [dbo].[NameStyle],
+                Phone [dbo].[Phone]);
+            INSERT INTO dbo.Customer (AccountNumber, Title, NameStyle, Phone)
+            VALUES ('AW-001', 'Ms.', 0, '555-1234');
+            """);
+        AreEqual(1, sim.ExecuteScalar("SELECT COUNT(*) FROM dbo.Customer"));
+        // Verify NOT NULL inheritance from alias: AccountNumber, Title,
+        // NameStyle should all be NOT NULL; Phone is nullable.
+        AreEqual(3, sim.ExecuteScalar(
+            "SELECT COUNT(*) FROM sys.columns WHERE object_id = OBJECT_ID('dbo.Customer') AND is_nullable = 0"));
+    }
+
+    [TestMethod]
+    public void CrossSchema_Alias_Resolves()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            CREATE SCHEMA HR;
+            """);
+        _ = sim.ExecuteNonQuery("""
+            CREATE TYPE HR.EmployeeId FROM int NOT NULL;
+            CREATE TABLE HR.Employee (Id HR.EmployeeId);
+            INSERT INTO HR.Employee (Id) VALUES (1);
+            """);
+        AreEqual(1, sim.ExecuteScalar("SELECT Id FROM HR.Employee"));
+    }
+}

SqlServerSimulator/AliasType.cs

@@ -0,0 +1,100 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// One scalar user-defined alias type (UDDT). Created via
+/// <c>CREATE TYPE schema.name FROM &lt;builtin&gt;[(N[, S])] [NULL | NOT NULL]</c>,
+/// dropped via <c>DROP TYPE [IF EXISTS] schema.name</c>. Lives in its owning
+/// <see cref="Schema"/>'s <see cref="Schema.AliasTypes"/> dict; shares the
+/// type-name namespace with <see cref="TableType"/> entries (Msg 219 on
+/// cross-kind dup-type-name collision).
+/// </summary>
+/// <remarks>
+/// <para>
+/// At resolution time the alias expands to its <see cref="UnderlyingType"/>;
+/// the <see cref="DeclaredMaxLength"/> applies to the underlying for
+/// length-bearing types (varchar / nvarchar / varbinary / char / nchar /
+/// binary / datetime2 / time / datetimeoffset / decimal / numeric).
+/// <see cref="IsNullable"/> carries the nullability marker declared on the
+/// alias itself (bare and explicit <c>NULL</c> are both nullable;
+/// <c>NOT NULL</c> is not). When a column / variable references an alias
+/// without an explicit nullability marker of its own, this default
+/// propagates — matches probe behavior against SQL Server 2025.
+/// </para>
+/// <para>
+/// Restrictions enforced at usage time (probe-confirmed against SQL Server
+/// 2025): a length parameter at the usage site raises Msg 2716 verbatim
+/// (<c>"Cannot specify a column width on data type X."</c>).
+/// </para>
+/// </remarks>
+internal sealed class AliasType(
+    Schema schema,
+    string name,
+    SqlType underlyingType,
+    int? declaredMaxLength,
+    int? declaredPrecision,
+    int? declaredScale,
+    bool isNullable,
+    int userTypeId,
+    DateTime createDate)
+{
+    public readonly Schema Schema = schema;
+
+    public readonly string Name = name;
+
+    /// <summary>
+    /// The resolved built-in type the alias wraps (e.g. <c>nvarchar(50)</c>'s
+    /// underlying is the simulator's <c>NVarchar</c> singleton). The fully-
+    /// resolved <c>SqlType</c> instance — declared length / precision / scale
+    /// from the CREATE TYPE source are captured in
+    /// <see cref="DeclaredMaxLength"/> / <see cref="DeclaredPrecision"/> /
+    /// <see cref="DeclaredScale"/> alongside since the singleton itself is
+    /// dimension-agnostic for most variable-length types.
+    /// </summary>
+    public readonly SqlType UnderlyingType = underlyingType;
+
+    /// <summary>
+    /// Declared length in characters / bytes (for variable-length string /
+    /// binary types) or the precision (for <c>datetime2</c> / <c>time</c> /
+    /// <c>datetimeoffset</c> / <c>decimal</c> / <c>numeric</c>'s precision
+    /// parameter). Null when the underlying is fixed-shape (e.g. <c>int</c>,
+    /// <c>bit</c>).
+    /// </summary>
+    public readonly int? DeclaredMaxLength = declaredMaxLength;
+
+    /// <summary>
+    /// Surfaced as the <c>sys.types.precision</c> column for the alias row.
+    /// Set from the underlying type's intrinsic precision (e.g. 10 for
+    /// <c>int</c>, 0 for <c>nvarchar</c>); not the CREATE TYPE
+    /// numeric-precision argument (that lands in
+    /// <see cref="DeclaredMaxLength"/> for <c>decimal</c> /
+    /// <c>numeric</c> / <c>datetime2</c> / <c>time</c> /
+    /// <c>datetimeoffset</c>).
+    /// </summary>
+    public readonly int? DeclaredPrecision = declaredPrecision;
+
+    /// <summary>
+    /// Decimal / numeric scale parameter. Null for non-decimal underlyings.
+    /// </summary>
+    public readonly int? DeclaredScale = declaredScale;
+
+    /// <summary>
+    /// Nullability marker from the CREATE TYPE declaration. Bare <c>CREATE
+    /// TYPE T FROM int</c> and explicit <c>NULL</c> both set this to true;
+    /// <c>NOT NULL</c> sets false. Used to default a column / variable's
+    /// nullability when the consumer has no explicit marker — see the
+    /// nullability-inheritance contract above.
+    /// </summary>
+    public readonly bool IsNullable = isNullable;
+
+    /// <summary>
+    /// Per-database <c>user_type_id</c> allocated via
+    /// <see cref="Database.AllocateUserTypeId"/>. Surfaces in
+    /// <c>sys.types.user_type_id</c> and <c>sys.columns.user_type_id</c>
+    /// (for columns whose declared type is this alias).
+    /// </summary>
+    public readonly int UserTypeId = userTypeId;
+
+    public readonly DateTime CreateDate = createDate;
+}

SqlServerSimulator/BuiltInResources.cs

@@ -870,6 +870,27 @@ private static IEnumerable<SqlValue[]> EnumerateSysTypes(Parser.BatchContext bat
                 ];
             }
         }
+        // Scalar alias types (UDDTs): probe-confirmed against SQL Server 2025
+        // — `system_type_id` is the **underlying** built-in's id (e.g. 56 for
+        // an alias of int, 231 for an alias of nvarchar), `is_user_defined`
+        // is true, `is_table_type` is false, and `is_nullable` reflects the
+        // alias-defined NULL/NOT NULL marker from CREATE TYPE.
+        foreach (var schema in batch.CurrentDatabase.Schemas.Values)
+        {
+            var schemaId = SqlValue.FromInt32(schema.SchemaId);
+            foreach (var alias in schema.AliasTypes.Values.OrderBy(a => a.UserTypeId))
+            {
+                yield return [
+                    SqlValue.FromSystemName(alias.Name),
+                    SqlValue.FromByte(alias.UnderlyingType.SystemTypeId),
+                    SqlValue.FromInt32(alias.UserTypeId),
+                    schemaId,
+                    trueBit,
+                    falseBit,
+                    alias.IsNullable ? trueBit : falseBit,
+                ];
+            }
+        }
     }
 
     private static IEnumerable<SqlValue[]> EnumerateSysTableTypes(Parser.BatchContext batch)

SqlServerSimulator/Errors/SimulatedSqlException.SchemaErrors.cs

@@ -196,6 +196,26 @@ internal static SimulatedSqlException SequenceExhausted(string fullName) =>
     internal static SimulatedSqlException TypeAlreadyExists(string fullName) =>
         new($"The type '{fullName}' already exists, or you do not have permission to create it.", 219, 16, 1);
 
+    /// <summary>
+    /// Mimics SQL Server error 222: <c>CREATE TYPE name FROM &lt;basetype&gt;</c>
+    /// referenced a base type that doesn't resolve to a built-in. Probe-
+    /// confirmed verbatim wording against SQL Server 2025 — the base-type name
+    /// appears in double-quotes inside the message text.
+    /// </summary>
+    internal static SimulatedSqlException InvalidBaseTypeForAlias(string baseTypeName) =>
+        new($"The base type \"{baseTypeName}\" is not a valid base type for the alias data type.", 222, 16, 1);
+
+    /// <summary>
+    /// Alias-type variant of Msg 2716: an alias-typed column / parameter /
+    /// variable declaration carries a width specifier (e.g.
+    /// <c>c dbo.MyAlias(100)</c>). Probe-confirmed State 3 against SQL Server
+    /// 2025 — distinct from <c>CannotSpecifyColumnWidth</c> (State 1, used
+    /// for builtin types). The alias's fully-qualified name
+    /// (<c>schema.name</c>) lands in the message verbatim.
+    /// </summary>
+    internal static SimulatedSqlException CannotSpecifyColumnWidthOnAlias(string aliasFullName, int index) =>
+        new($"Column, parameter, or variable #{index}: Cannot specify a column width on data type {aliasFullName}.", 2716, 16, 3);
+
     /// <summary>
     /// Mimics SQL Server error 218: <c>DROP TYPE</c> targeted a name that
     /// doesn't exist (suppressed by <c>IF EXISTS</c>). Probe-confirmed