OUTPUT INSERTED.* / DELETED.* / <source>.* star expansion — parse-time expansion across all three OUTPUT parsers (TryParseOutputClauseForMutation / TryParseOutputClause / TryParseMergeOutputClause). New TryDetectStarReference helper in Simulation.Output.cs uses SaveCheckpoint/RestoreCheckpoint to do lookahead-3 on the <Name>.* shape, leaving cursor on the * token for the caller to advance past; AppendStarExpansion synthesizes one Reference(qualifier, col) per target column (or per source-alias projected column, in MERGE), using the underlying column's leaf name as the output name (probe-confirmed against SQL Server 2025 — not the qualified INSERTED.col form). UPDATE / DELETE expand to the target table's columns under the existing allowInserted / allowDeleted gates (DELETE's INSERTED.* lands on Msg 4104 via the same path that already rejected INSERTED.col); INSERT expands INSERTED.* only; MERGE supports the full INSERTED.* / DELETED.* / <source>.* trio (DELETED columns NULL-fill on WHEN NOT MATCHED INSERT rows; INSERTED columns NULL-fill on WHEN MATCHED DELETE rows — inherited from the existing per-row resolver, no new runtime path). MERGE's $action handling refactored to flow through the same loop iteration with its alias-suffix check inline (previous structure forked the loop body before the alias check; star + $action coverage exposed it). Expansion runs before Expression.Parse, so the INSERTED.* AS alias shape inherits real SQL Server's Msg 102 rejection naturally — the cursor lands on , or end-of-OUTPUT terminator, never a bare alias-eligible Name. Unbound qualifier on .* raises Msg 4104 with the qualified form (foo.*) in the message. 11 new OutputClauseTests cover INSERT INSERTED.*, mixed-with-explicit, UPDATE both-stars, DELETE star, DELETE INSERTED.* and INSERT DELETED.* rejections, INSERT INSERTED.* INTO target, MERGE $action + INSERTED.* + DELETED.* with NULL-fill assertion across UPDATE / INSERT rows, MERGE source-alias s.*, and unbound-qualifier .* rejection. 3354 / 264 tests pass; dotnet format clean. CLAUDE.md "Not modeled" entry removed; docs/claude/dml.md OUTPUT bullet expanded with the parse-time-expansion mechanics, MERGE NULL-fill semantic, and alias-rejection inheritance note.

Author: RyanLamansky

CLAUDE.md

@@ -163,7 +163,6 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - `LIKE` with `COLLATE` override (default collation only).
 - `CONVERT` / `TRY_CONVERT` style codes other than `0` / `120` / `121`.
 - `LEN(ntext)` raising Msg 8116; legacy `READTEXT` / `WRITETEXT` / `UPDATETEXT`.
-- `OUTPUT DELETED.*` / `INSERTED.*` star expansion. (`OUTPUT INTO <target>` ships for both `@t` and regular tables — see Table variables below.)
 - MERGE source as a CTE-headed SELECT (`USING (WITH cte AS … SELECT …)`) — Selection.Parse's CTE entry doesn't reach the USING-clause grammar; wrap the CTE inside a regular SELECT instead. MERGE inside a CTE body, multi-statement MERGE WHEN-clause bodies, and `MERGE INTO <view>` (real SQL Server's updatable-view MERGE) are also deferred.
 - `PRIMARY KEY` / `UNIQUE` on a computed column (`NotSupportedException`).
 - Heap allocation tracking (flat page list, no IAM/PFS).

SqlServerSimulator.Tests/OutputClauseTests.cs

@@ -230,4 +230,179 @@ public void Merge_UpdatesScopeIdentity()
             when not matched then insert (v) values (i.v);
             select scope_identity()
             """));
+
+    [TestMethod]
+    public void InsertOutput_InsertedStar_ExpandsAllColumns()
+    {
+        using var reader = new Simulation().CreateCommand("""
+            create table t (id int identity, v int, c char(2) default 'AB');
+            insert t (v) output inserted.* values (10), (20)
+            """).ExecuteReader();
+
+        Assert.AreEqual(3, reader.FieldCount);
+        Assert.AreEqual("id", reader.GetName(0));
+        Assert.AreEqual("v", reader.GetName(1));
+        Assert.AreEqual("c", reader.GetName(2));
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(1, reader.GetInt32(0));
+        Assert.AreEqual(10, reader.GetInt32(1));
+        Assert.AreEqual("AB", reader.GetString(2));
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(2, reader.GetInt32(0));
+        Assert.AreEqual(20, reader.GetInt32(1));
+    }
+
+    [TestMethod]
+    public void InsertOutput_StarMixedWithExtra_AppendsAfter()
+    {
+        using var reader = new Simulation().CreateCommand("""
+            create table t (id int identity, v int);
+            insert t (v) output inserted.*, 'tag' as note values (5)
+            """).ExecuteReader();
+
+        Assert.AreEqual(3, reader.FieldCount);
+        Assert.AreEqual("id", reader.GetName(0));
+        Assert.AreEqual("v", reader.GetName(1));
+        Assert.AreEqual("note", reader.GetName(2));
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(1, reader.GetInt32(0));
+        Assert.AreEqual(5, reader.GetInt32(1));
+        Assert.AreEqual("tag", reader.GetString(2));
+    }
+
+    [TestMethod]
+    public void UpdateOutput_InsertedAndDeletedStar_BothExpand()
+    {
+        using var reader = new Simulation().CreateCommand("""
+            create table t (id int primary key, v int);
+            insert t values (1, 10), (2, 20);
+            update t set v = v + 100
+            output inserted.*, deleted.*
+            where id = 1
+            """).ExecuteReader();
+
+        Assert.AreEqual(4, reader.FieldCount);
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(1, reader.GetInt32(0));
+        Assert.AreEqual(110, reader.GetInt32(1));
+        Assert.AreEqual(1, reader.GetInt32(2));
+        Assert.AreEqual(10, reader.GetInt32(3));
+    }
+
+    [TestMethod]
+    public void DeleteOutput_DeletedStar_ExpandsAllColumns()
+    {
+        using var reader = new Simulation().CreateCommand("""
+            create table t (id int primary key, v int, n nvarchar(10));
+            insert t values (1, 10, 'a'), (2, 20, 'b');
+            delete t output deleted.* where id = 1
+            """).ExecuteReader();
+
+        Assert.AreEqual(3, reader.FieldCount);
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(1, reader.GetInt32(0));
+        Assert.AreEqual(10, reader.GetInt32(1));
+        Assert.AreEqual("a", reader.GetString(2));
+    }
+
+    [TestMethod]
+    public void DeleteOutput_InsertedStar_RaisesMsg4104()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (id int primary key, v int);
+            delete t output inserted.* where id = 1
+            """, 4104);
+
+    [TestMethod]
+    public void InsertOutput_DeletedStar_RaisesMsg4104()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (id int primary key, v int);
+            insert t output deleted.* values (1, 10)
+            """, 4104);
+
+    [TestMethod]
+    public void InsertOutput_StarInto_MatchesTargetColumnCount()
+    {
+        using var conn = new Simulation().CreateDbConnection();
+        conn.Open();
+        using (var setup = conn.CreateCommand())
+        {
+            setup.CommandText = "create table t (id int identity, v int); create table audit (id int, v int)";
+            _ = setup.ExecuteNonQuery();
+        }
+        using (var ins = conn.CreateCommand())
+        {
+            ins.CommandText = "insert t (v) output inserted.* into audit values (50)";
+            _ = ins.ExecuteNonQuery();
+        }
+        using var verify = conn.CreateCommand();
+        verify.CommandText = "select id, v from audit";
+        using var reader = verify.ExecuteReader();
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(1, reader.GetInt32(0));
+        Assert.AreEqual(50, reader.GetInt32(1));
+    }
+
+    [TestMethod]
+    public void MergeOutput_InsertedAndDeletedStar_NullForUnmatchedSide()
+    {
+        using var reader = new Simulation().CreateCommand("""
+            create table t (id int primary key, v int);
+            insert t values (1, 10);
+            merge t as tg
+            using (values (1, 100), (2, 200)) as s (id, v) on tg.id = s.id
+            when matched then update set v = s.v
+            when not matched by target then insert (id, v) values (s.id, s.v)
+            output $action, inserted.*, deleted.*;
+            """).ExecuteReader();
+
+        Assert.AreEqual(5, reader.FieldCount);
+        var rows = new List<(string action, int? insId, int? insV, int? delId, int? delV)>();
+        while (reader.Read())
+        {
+            rows.Add((
+                reader.GetString(0),
+                reader.IsDBNull(1) ? null : reader.GetInt32(1),
+                reader.IsDBNull(2) ? null : reader.GetInt32(2),
+                reader.IsDBNull(3) ? null : reader.GetInt32(3),
+                reader.IsDBNull(4) ? null : reader.GetInt32(4)));
+        }
+        rows.Sort((a, b) => (a.insId ?? 0).CompareTo(b.insId ?? 0));
+        Assert.HasCount(2, rows);
+        Assert.AreEqual("UPDATE", rows[0].action);
+        Assert.AreEqual(1, rows[0].insId);
+        Assert.AreEqual(100, rows[0].insV);
+        Assert.AreEqual(1, rows[0].delId);
+        Assert.AreEqual(10, rows[0].delV);
+        Assert.AreEqual("INSERT", rows[1].action);
+        Assert.AreEqual(2, rows[1].insId);
+        Assert.AreEqual(200, rows[1].insV);
+        Assert.IsNull(rows[1].delId);
+        Assert.IsNull(rows[1].delV);
+    }
+
+    [TestMethod]
+    public void MergeOutput_SourceAliasStar_ExpandsSourceColumns()
+    {
+        using var reader = new Simulation().CreateCommand("""
+            create table t (id int primary key, v int);
+            merge t
+            using (values (5, 50)) as s (id, v) on t.id = s.id
+            when not matched by target then insert (id, v) values (s.id, s.v)
+            output s.*;
+            """).ExecuteReader();
+
+        Assert.AreEqual(2, reader.FieldCount);
+        Assert.AreEqual("id", reader.GetName(0));
+        Assert.AreEqual("v", reader.GetName(1));
+        Assert.IsTrue(reader.Read());
+        Assert.AreEqual(5, reader.GetInt32(0));
+        Assert.AreEqual(50, reader.GetInt32(1));
+    }
+
+    [TestMethod]
+    public void Output_StarWithUnknownQualifier_Msg4104()
+        => _ = new Simulation().AssertSqlError("""
+            create table t (id int primary key, v int);
+            insert t output foo.* values (1, 10)
+            """, 4104);
 }

SqlServerSimulator/Simulation/Simulation.Merge.cs

@@ -610,19 +610,49 @@ SqlType ResolveOutputType(MultiPartName name)
         do
         {
             context.MoveNextRequired();
-            Expression expr;
             // $action pseudo-column: detected by the tokenizer's $action
             // single-token emission. Synthesize a literal reference that
             // the runtime resolves to the action verb via the row context.
             if (context.Token is UnquotedString u && u.Value.Equals("$action", StringComparison.OrdinalIgnoreCase))
             {
-                expr = new MergeActionReference();
+                Expression actionExpr = new MergeActionReference();
                 context.MoveNextOptional();
+                switch (context.Token)
+                {
+                    case ReservedKeyword { Keyword: Keyword.As }:
+                        actionExpr = Expression.AssignName(actionExpr, context.GetNextRequired<Name>());
+                        context.MoveNextOptional();
+                        break;
+                    case Name actionAlias:
+                        actionExpr = Expression.AssignName(actionExpr, actionAlias);
+                        context.MoveNextOptional();
+                        break;
+                }
+                expressions.Add(actionExpr);
+                columnNames.Add(string.IsNullOrEmpty(actionExpr.Name) ? "$action" : actionExpr.Name);
+                continue;
             }
-            else
+            if (TryDetectStarReference(context, out var starQualifier))
             {
-                expr = Expression.Parse(context);
+                string[]? cols = null;
+                if (Collation.Default.Equals(starQualifier, "INSERTED")
+                    || Collation.Default.Equals(starQualifier, "DELETED"))
+                {
+                    cols = new string[destinationTable.Columns.Length];
+                    for (var i = 0; i < destinationTable.Columns.Length; i++)
+                        cols[i] = destinationTable.Columns[i].Name;
+                }
+                else if (Collation.Default.Equals(starQualifier, sourceAlias))
+                {
+                    cols = sourceColumnNames;
+                }
+                if (cols is null)
+                    throw SimulatedSqlException.MultiPartIdentifierCouldNotBeBound($"{starQualifier}.*");
+                AppendStarExpansion(starQualifier, cols, expressions, columnNames);
+                context.MoveNextOptional();
+                continue;
             }
+            var expr = Expression.Parse(context);
             switch (context.Token)
             {
                 case ReservedKeyword { Keyword: Keyword.As }:
@@ -635,7 +665,7 @@ SqlType ResolveOutputType(MultiPartName name)
                     break;
             }
             expressions.Add(expr);
-            columnNames.Add(string.IsNullOrEmpty(expr.Name) && IsMergeActionRef(expr) ? "$action" : expr.Name);
+            columnNames.Add(expr.Name);
         }
         while (context.Token is Operator { Character: ',' });
 

SqlServerSimulator/Simulation/Simulation.Output.cs

@@ -1,11 +1,78 @@
 using SqlServerSimulator.Parser;
+using SqlServerSimulator.Parser.Expressions;
 using SqlServerSimulator.Parser.Tokens;
 using SqlServerSimulator.Storage;
 
 namespace SqlServerSimulator;
 
 partial class Simulation
 {
+    /// <summary>
+    /// Detects an <c>&lt;qualifier&gt;.*</c> star reference at the current
+    /// cursor position. When present, leaves the cursor on the <c>*</c>
+    /// operator (caller appends the expansion then calls
+    /// <see cref="ParserContext.MoveNextOptional"/>) and returns the
+    /// qualifier name. When absent (the cursor sees a regular expression
+    /// or a qualified non-star reference), restores to the original
+    /// position and returns <see langword="false"/> so the caller can
+    /// fall through to <see cref="Expression.Parse"/>.
+    /// </summary>
+    /// <remarks>
+    /// Probe-confirmed against SQL Server 2025 (2026-05-13): <c>INSERTED.*</c>
+    /// expands to every column of the destination table in storage order
+    /// (including identity / computed / default-bearing columns); <c>DELETED.*</c>
+    /// is the same shape; in MERGE OUTPUT the source-alias <c>s.*</c>
+    /// expands to the source's projected columns. Each expanded column
+    /// takes the underlying column's leaf name (not the qualified form).
+    /// <c>foo.* AS alias</c> isn't a valid shape — real SQL Server raises
+    /// Msg 102 ("Incorrect syntax near 'alias'"); the simulator inherits
+    /// that since star expansion advances past <c>*</c> and the parser
+    /// loop's alias-check sees the next token as either <c>,</c> or
+    /// statement-boundary, never a bare Name.
+    /// </remarks>
+    private static bool TryDetectStarReference(ParserContext context, out string qualifier)
+    {
+        qualifier = string.Empty;
+        if (context.Token is not Name namedToken)
+            return false;
+        var name = namedToken.Value;
+        var checkpoint = context.SaveCheckpoint();
+        if (!context.MoveNext() || context.Token is not Operator { Character: '.' })
+        {
+            context.RestoreCheckpoint(checkpoint);
+            return false;
+        }
+        if (!context.MoveNext() || context.Token is not Operator { Character: '*' })
+        {
+            context.RestoreCheckpoint(checkpoint);
+            return false;
+        }
+        qualifier = name;
+        return true;
+    }
+
+    /// <summary>
+    /// Appends one synthesized <see cref="Reference"/> per column in
+    /// <paramref name="columnNames"/> qualified by
+    /// <paramref name="qualifier"/>. Used by all three OUTPUT parsers
+    /// (mutation / insert / merge) for <c>INSERTED.* / DELETED.* /
+    /// &lt;source&gt;.*</c> expansion. The qualified Reference resolves
+    /// through the same per-row resolver that handles regular
+    /// <c>INSERTED.col</c> refs — no separate runtime path.
+    /// </summary>
+    private static void AppendStarExpansion(
+        string qualifier,
+        string[] columnNames,
+        List<Expression> expressions,
+        List<string> names)
+    {
+        for (var i = 0; i < columnNames.Length; i++)
+        {
+            expressions.Add(new Reference(qualifier, columnNames[i]));
+            names.Add(columnNames[i]);
+        }
+    }
+
     /// <summary>
     /// OUTPUT-clause parser for UPDATE / DELETE. Supports literal /
     /// parameter expressions and <c>INSERTED.&lt;col&gt;</c> /
@@ -44,6 +111,19 @@ partial class Simulation
         do
         {
             context.MoveNextRequired();
+            if (TryDetectStarReference(context, out var starQualifier))
+            {
+                var insertedRef = Collation.Default.Equals(starQualifier, "INSERTED");
+                var deletedRef = Collation.Default.Equals(starQualifier, "DELETED");
+                if ((insertedRef && !allowInserted) || (deletedRef && !allowDeleted) || (!insertedRef && !deletedRef))
+                    throw SimulatedSqlException.MultiPartIdentifierCouldNotBeBound($"{starQualifier}.*");
+                var columnNameList = new string[table.Columns.Length];
+                for (var i = 0; i < table.Columns.Length; i++)
+                    columnNameList[i] = table.Columns[i].Name;
+                AppendStarExpansion(starQualifier, columnNameList, expressions, names);
+                context.MoveNextOptional();
+                continue;
+            }
             var expr = Expression.Parse(context);
             switch (context.Token)
             {
@@ -341,6 +421,22 @@ SqlType ResolveOutputType(MultiPartName name)
         do
         {
             context.MoveNextRequired();
+            if (TryDetectStarReference(context, out var starQualifier))
+            {
+                if (Collation.Default.Equals(starQualifier, "INSERTED"))
+                {
+                    var cols = new string[destinationTable.Columns.Length];
+                    for (var i = 0; i < destinationTable.Columns.Length; i++)
+                        cols[i] = destinationTable.Columns[i].Name;
+                    AppendStarExpansion(starQualifier, cols, expressions, columnNames);
+                }
+                else
+                {
+                    throw SimulatedSqlException.MultiPartIdentifierCouldNotBeBound($"{starQualifier}.*");
+                }
+                context.MoveNextOptional();
+                continue;
+            }
             var expr = Expression.Parse(context);
             switch (context.Token)
             {

docs/claude/dml.md

@@ -7,7 +7,7 @@
 - **OUTPUT** supported only when the leading identifier resolves to a real table name; OUTPUT + alias-form multi-source → `NotSupportedException` (EF doesn't combine those).
 - **Multi-column SET evaluates RHS against pre-update snapshot** — `UPDATE t SET a = 100, b = a + 1` over `(a=10, b=20)` → `(a=100, b=11)`. Scalar subquery RHS sees pre-update state.
 - Identity update → Msg 8102. Computed update → Msg 271. Rowversion update → Msg 272. Per-row constraint re-validation: NOT NULL → Msg 515 ("UPDATE fails."); CHECK → Msg 547 ("UPDATE statement"); PK/UNIQUE → Msg 2627 (verbatim "Cannot insert duplicate key" wording even on UPDATE — SQL Server quirk). PK/UNIQUE validation runs against the post-update virtual state, so mass-shift on a unique key can false-positive (see Quirks).
-- `OUTPUT INSERTED.<col>` (post-update) / `DELETED.<col>` (pre-update). UPDATE allows both qualifiers; DELETE rejects `INSERTED.<col>` at parse → Msg 4104. Star expansion (`INSERTED.*`/`DELETED.*`) not modeled. `OUTPUT … INTO @t [(cols)]` ships for INSERT/UPDATE/DELETE/MERGE — see [Table variables](table-variables.md).
+- `OUTPUT INSERTED.<col>` (post-update) / `DELETED.<col>` (pre-update). UPDATE allows both qualifiers; DELETE rejects `INSERTED.<col>` at parse → Msg 4104. **Star expansion** (`INSERTED.*` / `DELETED.*`, plus the MERGE source-alias `<src>.*`) ships via parse-time expansion in `Simulation.Output.cs`: `TryDetectStarReference` peeks for the `<qualifier>.*` token sequence and `AppendStarExpansion` synthesizes one `Reference("qualifier", col)` per column of the target (or per column of the MERGE source alias). Expanded names take the underlying column's leaf (probe-confirmed — not the qualified form). The MERGE form keeps the per-action NULL-fill semantic for `INSERTED.* / DELETED.*` (DELETED columns are NULL on a WHEN NOT MATCHED INSERT row; INSERTED columns are NULL on a WHEN MATCHED DELETE row). Unbound qualifier on `.*` raises Msg 4104, same as `<qualifier>.<col>`. The expansion runs before `Expression.Parse`, so the alias-suffix shape (`INSERTED.* AS x`) inherits real SQL Server's Msg 102 rejection naturally — the cursor advances past `*` to either `,` or the end-of-OUTPUT terminator. `OUTPUT … INTO @t [(cols)]` ships for INSERT/UPDATE/DELETE/MERGE — see [Table variables](table-variables.md).
 
 ## `rowversion` (legacy synonym `timestamp`)
 8-byte big-endian database-scoped monotonic counter; advances on every INSERT into a rowversion-bearing table and every UPDATE affecting one. Storage type name surfaces as `timestamp` in `information_schema` regardless of declaration. Explicit insert → Msg 273; explicit update → Msg 272; second column on a table → Msg 2738. Outbound CAST: `varbinary(N)`/`binary(N)` copy 8 bytes; `bigint` reads big-endian. `Promote(RowVersion, Varbinary) → Varbinary` so EF's `WHERE [rv] = @originalRv` parameter works directly. EF `[Timestamp]` SaveChanges round-trips end-to-end.