test(ecs): prove standalone-computed factory aggregation type-checks cleanly

Adds a compile-time test for a common app pattern: computed factories
authored as standalone functions (annotated with the exported
`Database.Plugin.ToDatabase<typeof basePlugin>`) aggregated into one
`computed: {}` block in a createPlugin call. Covers a plain resource read, a
factory composing on a base computed, and a parameterized computed; asserts
the aggregated result types exactly, with no `Omit` and no cast.

Verified load-bearing: reverting the FullDBForPlugin CV slot to `unknown`
breaks this exact assignment with TS2322 (`unknown` not assignable to the
factory's `computed`), which is the contravariance failure that forced the
old `Omit<ToDatabase<...>, 'computed'>` workaround.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: krisnye

packages/data/src/ecs/database/create-plugin.type-test.ts

@@ -329,6 +329,72 @@ function validTypeInferenceTests() {
     });
 }
 
+// ============================================================================
+// Standalone computed factories aggregated in a create call
+// ============================================================================
+//
+// A common app pattern: computed factories are authored as standalone
+// functions in their own files, then aggregated into one `computed: {}` block
+// in a single createPlugin call. Each standalone factory must annotate its
+// `db` parameter with a NAMED, exported type (it lives in a different module
+// from the plugin).
+//
+// Before the FullDBForPlugin fix the factory db's `computed` slot was
+// `unknown`, so the annotation had to strip it:
+//     type CoreStateDatabase = Omit<Database.Plugin.ToDatabase<typeof core>, 'computed'>;
+// Now the factory sees the base plugin's already-resolved computeds, so the
+// plain exported `Database.Plugin.ToDatabase<typeof core>` is the correct,
+// cast-free annotation — AND it lets a standalone factory compose on a base
+// computed. This test proves the round trip type-checks cleanly: no `as`, no
+// `Omit`, no `@ts-expect-error`.
+function standaloneComputedFactoryAggregation() {
+    // The base "state" plugin owns the resources and one base computed.
+    const coreStatePlugin = createPlugin({
+        resources: {
+            count: { default: 0 as number },
+        },
+        computed: {
+            count: (db) => db.observe.resources.count,
+        },
+    });
+
+    // The single exported alias every standalone factory annotates against.
+    type CoreStateDatabase = Database.Plugin.ToDatabase<typeof coreStatePlugin>;
+
+    // Standalone factory (own file): reads a base resource.
+    const doubled = (db: CoreStateDatabase) =>
+        Observe.withMap(db.observe.resources.count, (v) => v * 2);
+
+    // Standalone factory (own file): composes on the base plugin's computed.
+    // This is the case the fix unlocks — `db.computed.count` is fully typed.
+    const isPositive = (db: CoreStateDatabase) =>
+        Observe.withMap(db.computed.count, (v) => v > 0);
+
+    // Standalone factory (own file): a parameterized computed that also reads
+    // a base computed.
+    const atLeast = (db: CoreStateDatabase) => (min: number) =>
+        Observe.withMap(db.computed.count, (v) => v >= min);
+
+    // Aggregate the independently-authored factories into the derived plugin's
+    // computed block — clean assignment, no cast.
+    const derived = createPlugin({
+        extends: coreStatePlugin,
+        computed: {
+            doubled,
+            isPositive,
+            atLeast,
+        },
+    });
+
+    // The resulting plugin exposes the aggregated computeds with exact types,
+    // alongside the inherited base computed.
+    type DerivedComputed = Database.FromPlugin<typeof derived>['computed'];
+    type _CheckDoubled = Assert<Equal<DerivedComputed['doubled'], Observe<number>>>;
+    type _CheckIsPositive = Assert<Equal<DerivedComputed['isPositive'], Observe<boolean>>>;
+    type _CheckAtLeast = Assert<Equal<DerivedComputed['atLeast'], (min: number) => Observe<boolean>>>;
+    type _CheckInheritedCount = Assert<Equal<DerivedComputed['count'], Observe<number>>>;
+}
+
 // ============================================================================
 // INVALID TYPE INFERENCE TESTS
 // ============================================================================