@@ -59,7 +59,7 @@ not shrink with compiler work — they are the shape of the target.
 | `EQ2008` | Query syntax using `join`, `let`, a second `from`, or `into` — its C# translation runs through compiler-generated transparent identifiers. Also the fenced initializer forms. | Rewrite in method syntax, where every operator is supported. |
 | `EQ2009` | A component is declared more than once in one file (partial declarations). eqc emits one module per declaration and cannot merge them. | Combine the members into a single declaration. |
 | `EQ2011` | A member that would take a name the runtime's component already uses. C# keeps a primary-constructor parameter, a field and a property apart, and spells them differently from the runtime's camelCase; JavaScript folds all of it onto `this.<name>`, so the assignment replaces the runtime's member and the page fails only in the browser. The list is read from the live runtime (`core/runtime-members.spec.ts` → `Resources/runtime-members.txt`), never typed. | Rename the member. An `override` is exempt — a component's `Build` is meant to replace the runtime's `build`, and replacing a base member is what one is for — but a plain method is not: `public void Mount() { }` overrides nothing and still emits `mount()` over the runtime's own, so the component never mounts. |
-| `EQ2010` | A symbol the framework keeps on the HOST — a type or a single member marked `[ServerOnly]` — named from client code. The runtime ships no twin, so the reference would compile, emit, and fail at hydration on "does not provide an export named" while SSR kept answering 200. | Call it from server code: a `[ServerAction]`, a `[ServerOnly]` class, or a realizer. Never from a component's `Build`. Unlike `EQ2004` this is a DECISION, not a gap — adding a strategy is not the answer. |
+| `EQ2010` | A symbol the framework keeps on the HOST — a type or a single member marked `[ServerOnly]` — named from client code. The runtime ships no twin, so the reference would compile, emit, and fail at hydration on "does not provide an export named" while SSR kept answering 200. A type declared inside one that never crosses (a `[ServerOnly]` class, an exception or an attribute) has no twin either, as its owner has none, so client code that reaches it is refused the same way, however it reaches it: its name, an alias, `using static`, an operator or a conversion its value brings, or a zero. A module that would import its twin reports it at the declaration that holds the reference (#584). | Call it from server code: a `[ServerAction]`, a `[ServerOnly]` class, or a realizer. Never from a component's `Build`. Unlike `EQ2004` this is a DECISION, not a gap — adding a strategy is not the answer. |
 | `EQ2012` | A `[ServerAction]` on an ABSTRACT component. The server registers an action under the name of the CONCRETE component carrying it — `ServerActionRegistry.ScanAssembly` skips abstract types and walks inherited methods — so it serves `Tile/Load` while a stub emitted on the base would invoke `CardBase/Load`. Nothing serves that id and the page gets "action not found", on both sides silently. | Declare the action on the concrete component. An alias is not the answer: the descriptor carries the component TYPE to invoke on, so two children inheriting one action give the base's id two answers — the owner of an inherited action is a decision, not a patch. |
 | `EQ2013` | A vocabulary type whose browser half revives the values of a type argument (`ServerTopic<T>`, its parameter marked `[HydratesTypeArgument]`) is built where that argument is, or holds, a type parameter: `static ServerTopic<T> Topic<T>(string name) => new(name)`. JavaScript erases the type there, so the topic would carry no spec and every payload would reach its subscribers unrevived, a decimal or a long as the text the wire writes. | Build the topic where its payload type is concrete, as a static member of the type that declares the app's topics: `static ServerTopic<RoomEvent> Room(string id) => new($"room:{id}")`. |
 
 
@@ -2199,6 +2199,24 @@ record of a release, the wiki's Upgrading page is the distillate.
   reason, most of them members lowered to JavaScript's own method, where refusing a null by name is a
   guard at every call, a decision. Proposed and archived through OpenSpec
   (`openspec/specs/transpiler-exceptions`).
+- **2026-10-06 · A nested class is a module of its own, named by its owner**: a class declared inside
+  another one had no module, so `Roster.First()` building a private `Row` threw, and where a top-level
+  class had its name the nested one resolved to it, so `new Cart().Size()` read the top-level `Item`'s
+  3 for its own 9 ([#584](https://github.com/eQuantic/equantic-ui/issues/584)); a nested record wrote
+  the module a top-level record of its name writes, and the two were refused (EQ2009); a nested static
+  class outside a component had no module. Every class, static class, record and struct declared
+  inside another type is a module named by the types that contain it and its own name joined by `$`
+  (`Cart$Item`), which no C# type can take, and every reference to it, a construction, a type test, a
+  static member, an operator, a zero and an annotation alike, names that twin and imports it, through
+  one name the parser, the resolver and the emitters read; one inside a server-only class, an
+  exception or an attribute has none, and client code that reaches it, by a name, an alias, `using
+  static`, an operator or a zero, is refused with EQ2010, the import every module makes being the net
+  under the fences; one inside a type the runtime provides is the runtime's. A record's text keeps its
+  C# name. The runtime's one nested type is `CodeBlock$CodeMetrics`. The server names the page it
+  serves by the same rule, one file linked into both (`TwinName.OfType`): a page declared inside a
+  class asked the browser for a module named by its simple name, which nothing writes any more, and
+  one inside an owner that never crosses has no route and cannot be mapped. Proposed and archived through OpenSpec
+  (`openspec/specs/transpiler-classes`).
 
 ## Retired documents
 
 
@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-10-06
@@ -0,0 +1,66 @@
+# Design
+
+## Context
+
+eqc writes one module per type, named by the type, and a module that names another imports it as
+`import { X } from "./X"`. The name was the type's simple C# name everywhere: the parser's
+definitions, the dependency resolver's set of modules, the emitters' class declarations, and every
+strategy that writes a type into code (`new`, `instanceof`, a static member, an operator, a zero, an
+annotation, a hydration map). A nested type broke the scheme three ways: a plain class or a static
+class nested outside a component had no module, a component's nested static classes were written into
+the component's module unexported, and a nested record or struct had a module named like a top-level
+type, which could write the same file.
+
+## Goals / Non-Goals
+
+**Goals:**
+
+- One name for a type's twin, read by everything that writes or resolves one.
+- A nested type is a module like any other, so the import machinery that exists serves it unchanged.
+
+**Non-Goals:**
+
+- A nested enum or interface: an enum lowers to its values and an interface to nothing.
+- Reflection's names (`GetType().Name`, `nameof`), which stay the C# names.
+
+## Decisions
+
+### `Owner$Nested`, a module of its own
+
+The twin of a type declared inside another is named by the chain of the types that contain it and its
+own name joined by `$`: `Cart$Item`, `A$B$C`, generic arguments erased (`Box<T>.Node` is `Box$Node`).
+C# allows no `$` in a name, so the twin can never meet a top-level type's, and its module is named
+the same. Every reference writes that name and the module that holds the reference imports it from
+`./Cart$Item`, through the machinery a top-level type already takes.
+
+Alternative: write the nested types into their owner's module, as a component's nested static
+classes were. Rejected: every emitter would need to merge another type's code and imports into its
+own, a reference from outside the owner would need the owner's module to re-export it, and the four
+emitters would each carry a second shape of module. Alternative: the owner's static property
+(`Cart.Item`). Rejected: TypeScript cannot read a value as a type, so every annotation of a nested
+type would be `any`, and the owner's module would have to be loaded before its nested type's.
+
+### One name, read everywhere
+
+A type symbol's twin name (`TwinName`) and a declaration's (the same walk over its parents, for a
+host with no model) replace the simple name in the parser, the dependency resolver's scan, the
+emitters' class declarations and the strategies that write a type. A record's text keeps the C# name
+it prints, as .NET's `PrintMembers` writes it, and so do the diagnostics, which speak C#.
+
+How Flutter answers it: Dart has no nested classes, so a library writes each class at its top level
+under a name of its own, and a private one takes a leading `_`. The `$` is the same idea in a name C#
+cannot spell.
+
+### Who has a twin
+
+A nested type has a twin where a top-level type of its kind would, and where its owner crosses: a
+nested type of a `[ServerOnly]` owner, an exception or an attribute has none, as its owner has none,
+whatever it is itself. A component's nested static class is a static helper's module like any other.
+
+## Risks / Trade-offs
+
+- [A module file whose name holds a `$`] → the bundler, the server's module route and every host's
+  file system take it; the conformance suite runs the bundled graph, and the dashboard sample serves
+  it.
+- [A hand-written runtime file naming `CodeMetrics`] → none: only the transpiled `CodeBlock` reads it,
+  and it regenerates.
@@ -0,0 +1,56 @@
+# Proposal
+
+Closes #584, a sub-issue of #565 (the transpiler's fences hold on every path, continued). It builds on
+the class construction of #583, whose branch this one follows.
+
+## Why
+
+A type declared inside another one is its owner's scope in C#, and eqc had no single answer for it,
+measured through the module graph an app's build writes, both sides executed:
+
+- A nested class that is not a component's static helper got no module, so constructing it named a
+  class the browser does not have: `Roster.First()` building a private `Row` answered "Ada" in .NET
+  and threw in the browser.
+- Where a top-level class has the nested one's name, the nested one resolved to it:
+  `new Cart().Size()` over a private `Cart.Item` with `Qty = 9`, beside a top-level `Item` with
+  `Qty = 3`, was 9 in .NET and 3 in the browser.
+- A nested record or struct got a module named by its simple name, which a top-level type of that
+  name writes too, one file over the other.
+- A nested static class outside a component got no module, and one inside a component was written
+  into the component's module under its simple name.
+
+## What Changes
+
+- Every class, record and struct declared inside another type has a twin of its own, named by the
+  chain of the types that contain it and its own name, joined by `$` (`Cart$Item`, `A$B$C`): a name no
+  C# type can take, so it never meets a top-level type's. Its module is named so, and every reference
+  to it, inside its owner or out, a construction, a type test, a static member, a default and an
+  annotation alike, names it so, importing it from there.
+- A nested type of an owner that never crosses (`[ServerOnly]`, an exception, an attribute) has none,
+  as its owner has none: client code that names it is refused with EQ2010, and the server publishes no
+  route to a page declared in it.
+- A record's text still prints its C# name (`Line { Qty = 2 }`), as .NET's does.
+- The runtime's one nested type, `CodeBlock.CodeMetrics`, is written as `CodeBlock$CodeMetrics`. The
+  developer surface does not move. `eQuantic.UI.Compiler`'s does: `UserDefinedOperators.Unary` and
+  `Binary` take the conversion context, so the twin an operator names is imported, and
+  `TypeSymbolExtensions.IntroduceTwin` is new.
+
+## Capabilities
+
+### New Capabilities
+
+None.
+
+### Modified Capabilities
+
+- `transpiler-classes`: a nested class, record or struct is a module of its own, named by its owner.
+
+## Impact
+
+- eqc: one name for a type's twin (its containing types and its own name), which the parser, the
+  dependency resolver, every emitter and every strategy that names a type in the code it writes read;
+  the parser discovers nested types as modules; a component no longer writes its nested static
+  classes into its own module.
+- The runtime: `CodeMetrics` regenerates as `CodeBlock$CodeMetrics`.
+- Tests: conformance cases through the module graph for each shape, both sides executed.
+- Docs: the wiki's SupportedFeatures page (English and Portuguese) and one docs/LEDGER.md line.
@@ -0,0 +1,95 @@
+## ADDED Requirements
+
+### Requirement: A nested type is a module of its own, named by its owner
+
+Every class, record and struct declared inside another type SHALL have a twin of its own, in a module
+of its own, named by the chain of the types that contain it and its own name joined by `$`
+(`Cart$Item`), which no C# type can take. Every reference to it, inside its owner or out, SHALL name
+that twin: a construction, a type test, a static member, a default and an annotation alike. A nested
+type of an owner that never crosses (`[ServerOnly]`, an exception, an attribute) SHALL have none, and
+client code that reaches its twin SHALL be refused: one that builds it, tests for it, reads its statics,
+takes its zero or calls an operator or a conversion its value brings, however the code names the type
+(an alias, `using static`, inference). A module that would import such a twin SHALL report it rather
+than import it. A nested type of an owner the runtime provides SHALL be the runtime's,
+imported from it under its twin name. A record's text SHALL print its C# name, as .NET's does. The server SHALL name the page it serves by the
+same rule, so a page declared inside a class loads the module the build wrote for it, and SHALL refuse to
+map a page declared inside an owner that never crosses.
+
+#### Scenario: A nested class beside a top-level class of its name
+
+- **WHEN** `class Item { public int Qty = 3; }` and `class Cart { private class Item { public int Qty = 9; } public int Size() => new Item().Qty; }`
+- **THEN** `new Cart().Size()` is `9`, as in .NET
+
+#### Scenario: A private nested class built by its owner
+
+- **WHEN** `class Roster { private sealed class Row { public string Name = ""; } public static string First() { var r = new Row { Name = "Ada" }; return r.Name; } }`
+- **THEN** `Roster.First()` is `Ada`, as in .NET
+
+#### Scenario: A nested record beside a top-level record of its name
+
+- **WHEN** `class Shop { public record Line(int Qty); }` and `record Line(string Text);`
+- **THEN** `new Shop.Line(2).Qty` is `2`, `new Line("x").Text` is `x`, and `new Shop.Line(2)` prints `Line { Qty = 2 }`, as in .NET
+
+#### Scenario: A nested static class of a plain class
+
+- **WHEN** `class Calc { static class Ops { public static int Twice(int x) => x * 2; } public int Run(int x) => Ops.Twice(x); }`
+- **THEN** `new Calc().Run(4)` is `8`, as in .NET
+
+#### Scenario: A public nested type from outside its owner
+
+- **WHEN** `class Outer { public class Inner { public int N = 4; } }` and `object o = new Outer.Inner();`
+- **THEN** `((Outer.Inner)o).N` is `4` and `o is Outer.Inner` is true, as in .NET
+
+#### Scenario: Two levels of nesting
+
+- **WHEN** `class A { public class B { public class C { public int V = 1; } } }`
+- **THEN** `new A.B.C().V` is `1`, as in .NET
+
+#### Scenario: A nested type of a server-only owner
+
+- **WHEN** `[ServerOnly] class Vault { public class Key { } }`
+- **THEN** the build writes no module for `Key`, as it writes none for `Vault`, client code that builds a
+  `Vault.Key` or tests for one is refused with EQ2010, and a page declared inside `Vault` has no route,
+  and mapping it with `MapPage` fails at startup
+
+#### Scenario: A kept-out nested type the syntax never names
+
+- **WHEN** `[ServerOnly] class Vault` holds `Key`, `Pair` and `Amount`, and client code reads `K.Count` through
+  `using K = Vault.Key;`, reads `Count` or calls `Make()` through `using static Vault.Key;`, asks for
+  `default(Vault.Pair)`, declares a field of type `Vault.Pair`, or adds or converts a `Vault.Amount` that
+  another class's method returns
+- **THEN** each is refused with EQ2010, and no module imports a twin of `Vault`'s
+
+#### Scenario: A nested type of a runtime-provided owner
+
+- **WHEN** `[RuntimeProvided] class Kit { public class Part { } }` and client code builds a `Kit.Part`
+- **THEN** the module imports `Kit$Part` from the runtime, which carries it as it carries
+  `CodeBlock$CodeMetrics`, and the build writes no module for it
+
+#### Scenario: A page declared inside a class
+
+- **WHEN** `public static class Admin { [Page("/admin/users")] public class Users : StatelessComponent { … } }` is served
+- **THEN** the page's configuration and its route name `Admin$Users`, the module the build wrote
+
+#### Scenario: A nested component, tested and built by its twin
+
+- **WHEN** `class Host { public class Page : StatelessComponent { … } }`, `object o = new Host.Page();` and `Host.Page p = new();`
+- **THEN** `o is Host.Page` tests `Host$Page`, and both constructions build `Host$Page`, imported where it is used
+
+#### Scenario: A component beside a nested class of its name
+
+- **WHEN** `class Item : StatelessComponent { … }` and `class Cart { public class Item { } }`
+- **THEN** `Item` is the component's module and `Cart$Item` a plain class's, neither taken for the other
+
+#### Scenario: A nested type the syntax never names
+
+- **WHEN** `Factory.Make() + Factory.Make()`, `-Factory.Make()` and `total += Factory.Make()` bind the operators of a
+  nested `Outer.Amount` that no expression names, and `default(Alias)` is the zero of a nested struct through
+  `using Alias = Outer.Pair;`
+- **THEN** each module imports `Outer$Amount` and `Outer$Pair`, as it imports a twin the syntax names
+
+#### Scenario: A nested type inside an array or a generic
+
+- **WHEN** a member is typed `A.Inner[]`, `List<A.Inner>` or `Func<A.Inner, B.Inner>`, in a class or a record
+- **THEN** its annotation names `A$Inner` and `B$Inner`, each where its type stands, and a top-level `Inner`
+  beside them keeps its own name
@@ -0,0 +1,20 @@
+# Tasks
+
+## 1. One name for a twin
+
+- [x] 1.1 A type's twin name, from its symbol and from its declaration: the chain of its containing types and its own name joined by `$`, generic arguments erased. Verified by Compiler tests for a top-level, a nested, a doubly nested and a generic owner's type
+- [x] 1.2 Every strategy and emitter that writes a type into code names its twin: a construction, a type test, a static member, an operator, a conversion, a zero, a `with`, an annotation, a hydration map and a class declaration. Verified by the conformance cases of group 2 and the Compiler suite
+
+## 2. A nested type is a module
+
+- [x] 2.1 The parser and the dependency resolver take a nested class, static class, record and struct as a module named by its twin, and none for one whose owner never crosses; a component's nested static classes are modules like any other. Verified by conformance cases through the module graph (the two of #584, a nested record beside a top-level one, a nested static class, a public nested type from outside, two levels), failing before and green here, and a Compiler test for the server-only owner
+
+## 3. The runtime and the real thing
+
+- [x] 3.1 Regenerate the runtime's transpiled classes (`CodeBlock$CodeMetrics`) and run `dotnet build src/eQuantic.UI.Runtime -t:TestRuntime`, the Server suite and the Web suite
+- [x] 3.2 The dashboard sample in a browser: the code screens, whose `CodeBlock` builds a nested record, render with no console error
+
+## 4. Documentation and archive
+
+- [x] 4.1 The wiki's SupportedFeatures page in English and Portuguese, on the wiki branch named like this change's branch, and one docs/LEDGER.md line citing #584
+- [x] 4.2 `./scripts/check-openspec.sh` green, then `openspec archive a-nested-class-is-its-owners --yes` before the merge
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+schema: spec-driven`
	`2`	`+created: 2026-10-06`