diff --git a/README.md b/README.md
index f9a8e29..36d7a22 100644
--- a/README.md
+++ b/README.md
@@ -41,8 +41,8 @@ The Flamework transformer must be configured in your `tsconfig.json`. The fields
 			{
 				"transform": "rbxts-transformer-flamework",
 			},
-		]
-	}
+		],
+	},
 }
 ```
 
@@ -67,60 +67,135 @@ You should find the entry for `node_modules` and modify it to include `@flamewor
 
 You may need to delete the `out` folder and recompile for Flamework's transformer to begin working. Afterwards, you are ready to use flamecs.
 
-## Demo
+## Components
 
-```ts
-const positionEntity = spawn<[Vector3]>([new Vector3(10, 20, 30)]);
-print(has<Vector3>(positionEntity));
+```typescript
+interface Position {
+	x: number;
+	y: number;
+}
 
-start({}, () => {
-	if (useThrottle(5)) {
-		for (const [entity, position, orientation] of query<[Vector3, CFrame]>()) {
-			print(`Entity: ${entity}, Position: ${position}, Orientation: ${orientation}`);
-		}
-	}
-});
+// Tag (no data)
+interface Player extends Tag {}
+
+// Components can be wrapped to use non-table data
+interface Name extends Wrap<string> {}
+interface Health extends Wrap<number> {}
+```
+
+## Entities
+
+### Spawning Entities
+
+```typescript
+const entity = spawn();
+
+// When spawning with tags the bundle list can be omitted
+const marcus = spawn<[Player]>();
+
+const ketchup = spawn<[Position, Player]>([{ x: 0, y: 0 }]);
+
+// Get the runtime entity id from a component
+const positionComponent = component<Position>();
+```
+
+### Modifying Entities
+
+```typescript
+add<Player>(entity);
+
+set<Position>(entity, { x: 10, y: 20 });
+set<Name>(entity, "Alice");
+
+// Insert can be used to add/set multiple components
+insert<[Name, Health, Player]>(entity, ["Bob", 100]);
+
+remove<Player>(entity);
+
+if (has<Player>(entity)) {
+	// ...
+}
+
+const pos = get<Position>(entity);
+const name = get<Name>(entity);
+
+despawn(entity);
+```
+
+## Queries
+
+```typescript
+for (const [entity, pos, name] of query<[Position, Name]>()) {
+	print(`${name} at ${pos.x}, ${pos.y}`);
+}
 
-for (const [entity, position] of query<[Vector3, Without<[CFrame]>]>()) {
-	print(`Entity: ${entity}, Position: ${position}`);
+for (const [entity, pos] of query<[Position, Without<Player>]>()) {
+	// ...
 }
 
-// Example of using pair relationships between entities
-interface Likes {}
-interface Eats {
-	count: number;
+for (const [entity, pos] of query<[Position, With<[Player, Health]>]>()) {
+	// ...
 }
+```
 
-interface Fruit {}
+## Relationships
 
-const alice = spawn();
-const bob = spawn();
-const charlie = spawn();
+### Defining Relationships
 
-const banana = spawn();
-add<Fruit>(banana);
+```typescript
+interface Likes extends Tag {}
+interface Owns extends Wrap<number> {}
 
+// Alice likes Bob
 add<Pair<Likes>>(alice, bob);
-add<Pair<Likes>>(alice, charlie);
 
-add<Pair<Likes, Fruit>>(bob);
+// Alice owns 5 items
+set<Pair<Owns, Item>>(alice, 5);
+```
 
-set<Pair<Eats>>(bob, banana, { count: 5 });
-set<Pair<Eats, Fruit>>(alice, { count: 12 });
+### Querying Relationships
 
-for (const [entity] of query().pair<Likes>(alice)) {
-	const likedEntity = target<Likes>(entity);
-	print(`Entity ${entity} likes ${likedEntity}`);
+```typescript
+// Query all entities that like something Pair<Likes, Wildcard>
+for (const [entity] of query<[Pair<Likes>]>()) {
+	const target = target<Likes>(entity);
+	print(`${entity} likes ${target}`);
 }
 
-for (const [entity, eatsData] of query<[Pair<Eats, Fruit>]>()) {
-	const eatsTarget = target<Eats>(entity);
-	print(`Entity ${entity} eats ${eatsData.count} fruit (${eatsTarget})`);
+// Query specific relationships where the object is a runtime id
+for (const [entity] of query().pair<Likes>(bob)) {
+	// ...
 }
+```
 
-// Using Pair<P> to match any target (wildcard), equivalent to Pair<Likes, Wildcard>
-for (const [entity] of query<[Pair<Likes>]>()) {
-	const likedTarget = target<Likes>(entity);
-	print(`Entity ${entity} likes ${likedTarget}`);
-}
+## Signals
+
+```typescript
+added<Position>().connect((entity) => {
+	print(`Position added to ${entity}`);
+});
+
+removed<Position>().connect((entity) => {
+	print(`Position removed from ${entity}`);
+});
+
+changed<Position>().connect((entity, newValue) => {
+	print(`Position of ${entity} changed to ${newValue}`);
+});
+```
+
+## Hooks and Systems
+
+```typescript
+// Hooks must be used within a `start()` function.
+start({}, () => {
+	if (useThrottle(0.5)) {
+		// ...
+	}
+
+	for (const [player] of useEvent(Players.PlayerAdded)) {
+		const entity = spawn<[Name, Player]>([player.Name]);
+		// ...
+	}
+});
 ```
diff --git a/src/index.ts b/src/index.ts
index 61d8dd6..2a42b26 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,7 +1,7 @@
 export * from "./hooks/use-event";
 export * from "./hooks/use-throttle";
 export * from "./query";
-export type { ChildOf, Entity, Id, Pair, Tag, Wildcard } from "./registry";
+export type { ChildOf, Entity, Id, Name, Pair, Tag, Wildcard, Wrap } from "./registry";
 export {
 	add,
 	added,
@@ -17,6 +17,7 @@ export {
 	remove,
 	removed,
 	reserve,
+	reset,
 	set,
 	spawn,
 	target,
diff --git a/src/query.ts b/src/query.ts
index 3deb522..1e6fd30 100644
--- a/src/query.ts
+++ b/src/query.ts
@@ -1,7 +1,6 @@
-import type { Modding } from "@flamework/core";
 import * as ecs from "@rbxts/jecs";
 
-import type { Entity, FilterPairs, Id, ResolveKeys } from "./registry";
+import type { ComponentKey, Entity, Id, ResolveKeys, ResolveValues, Unwrap } from "./registry";
 import { component, getId, registry } from "./registry";
 
 // Almost full credits to @fireboltofdeath for all of these types.
@@ -37,7 +36,10 @@ type Calculate<T extends Array<unknown>, B extends Bounds = Bounds> = T extends
 			: Calculate<Skip<T>, PushBound<B, "query", T[0]>>;
 
 type ToIds<T> = T extends [] ? undefined : ResolveKeys<T>;
-type ExtractQueryTypes<T extends Array<unknown>> = Reconstruct<FilterPairs<Calculate<T>["query"]>>;
+
+type ExtractQueryTypes<T extends Array<unknown>> = Reconstruct<
+	ResolveValues<Calculate<T>["query"]>
+>;
 
 type QueryHandle<T extends Array<unknown>> = {
 	__iter(): IterableFunction<LuaTuple<[Entity, ...T]>>;
@@ -53,19 +55,19 @@ type QueryHandle<T extends Array<unknown>> = {
 	 * @returns A new QueryHandle with the pair filter added.
 	 * @metadata macro
 	 */
-	pair<P>(object: Entity, predicate?: Modding.Generic<P, "id">): QueryHandle<[...T, P]>;
+	pair<P>(object: Entity, predicate?: ComponentKey<P>): QueryHandle<[...T, Unwrap<P>]>;
 	terms?: Array<Id>;
 } & IterableFunction<LuaTuple<[Entity, ...T]>>;
 
 function queryPair<T extends Array<unknown>, P>(
 	this: QueryHandle<T>,
 	object: Entity,
-	predicate?: Modding.Generic<P, "id">,
-): QueryHandle<[...T, P]> {
+	predicate?: ComponentKey<P>,
+): QueryHandle<[...T, Unwrap<P>]> {
 	assert(predicate);
 	const id = ecs.pair(component(predicate), object);
 	this.terms = this.terms ? [...this.terms, id] : [id];
-	return this as unknown as QueryHandle<[...T, P]>;
+	return this as unknown as QueryHandle<[...T, Unwrap<P>]>;
 }
 
 function queryIter<T extends Array<unknown>>(
diff --git a/src/registry.ts b/src/registry.ts
index c0930ea..3a68100 100644
--- a/src/registry.ts
+++ b/src/registry.ts
@@ -1,31 +1,41 @@
 import type { Modding } from "@flamework/core";
 import * as ecs from "@rbxts/jecs";
 
-import { createSignal, type Signal } from "./signal";
+import type { Signal } from "./signal";
+import { createSignal } from "./signal";
 
-export interface Wildcard {}
-export interface ChildOf {}
+export interface Wrap<T> {
+	readonly _flamecs_type: T;
+}
+export interface Tag extends Wrap<undefined> {}
+
+export interface ChildOf extends Tag {}
+export interface Wildcard extends Tag {}
+export interface Name extends Wrap<string> {}
 
-export type Entity<T = unknown> = ecs.Entity<T>;
 export type Id<T = unknown> = ecs.Id<T>;
+export type Entity<T = unknown> = ecs.Entity<T>;
 export type Pair<P = undefined, O = undefined> = ecs.Pair<P, O>;
-export type Tag = ecs.Tag;
+
+export type ExtractPredicate<T> = T extends Pair<infer P, unknown> ? P : T;
+export type Unwrap<T> = T extends Wrap<infer Inner> ? Inner : T;
+
+export type ResolveValue<T> = Unwrap<ExtractPredicate<T>>;
+export type ResolveValues<T> = { [K in keyof T]: ResolveValue<T[K]> };
 
 export type ComponentKey<T> = Modding.Generic<T, "id">;
 export type PairKey<P, O> = Modding.Many<{
 	obj: ComponentKey<O extends defined ? O : Wildcard>;
 	pred: ComponentKey<P extends defined ? P : Wildcard>;
 }>;
-
 export type ResolveKey<T> = T extends Pair<infer P, infer O> ? PairKey<P, O> : ComponentKey<T>;
 export type ResolveKeys<T> = Modding.Many<{
 	[K in keyof T]: ResolveKey<T[K]>;
 }>;
 
-export type FilterPair<T> = T extends Pair<infer P, unknown> ? P : T;
-export type FilterPairs<T> = {
-	[K in keyof T]: FilterPair<T[K]>;
-};
+type TrailingUndefined<T extends Array<unknown>> = T extends [...infer Rest, undefined]
+	? [...TrailingUndefined<Rest>, undefined?]
+	: T;
 
 const components = new Map<string, Entity>();
 export const registry = new ecs.World();
@@ -36,22 +46,50 @@ export const signals = {
 	removed: new Map<Entity, Signal<[Entity]>>(),
 };
 
-export function added<T>(id: Entity<T>): Signal<[Entity<T>]> {
+/**
+ * Returns a signal that fires when a component is added to an entity.
+ *
+ * @template T - The type of the component.
+ * @param key - Flamework autogenerated key for the component.
+ * @returns A signal that fires when the component is added to any entity.
+ * @metadata macro
+ */
+export function added<T>(key?: ComponentKey<T>): Signal<[Entity<T>]> {
+	const id = component(key);
 	return signals.added.get(id)! as Signal<[Entity<T>]>;
 }
 
-export function removed<T>(id: Entity<T>): Signal<[Entity<T>]> {
+/**
+ * Returns a signal that fires when a component is removed from an entity.
+ *
+ * @template T - The type of the component.
+ * @param key - Flamework autogenerated key for the component.
+ * @returns A signal that fires when the component is removed from any entity.
+ * @metadata macro
+ */
+export function removed<T>(key?: ComponentKey<T>): Signal<[Entity<T>]> {
+	const id = component(key);
 	return signals.removed.get(id)! as Signal<[Entity<T>]>;
 }
 
-export function changed<T>(id: Entity<T>): Signal<[Entity<T>, T]> {
+/**
+ * Returns a signal that fires when a component's value changes on an entity.
+ *
+ * @template T - The type of the component.
+ * @param key - Flamework autogenerated key for the component.
+ * @returns A signal that fires when the component's value changes on any
+ *   entity.
+ * @metadata macro
+ */
+export function changed<T>(key?: ComponentKey<T>): Signal<[Entity<T>, T]> {
+	const id = component(key);
 	return signals.changed.get(id)! as Signal<[Entity<T>, T]>;
 }
 
-function hookListeners<T>(id: Entity<T>): void {
+function hookListeners(id: Entity): void {
 	const addedSignal = createSignal<[Entity]>();
 	const removedSignal = createSignal<[Entity]>();
-	const changedSignal = createSignal<[Entity, T]>();
+	const changedSignal = createSignal<[Entity, unknown]>();
 	signals.added.set(id, addedSignal);
 	signals.removed.set(id, removedSignal);
 	signals.changed.set(id, changedSignal);
@@ -63,7 +101,7 @@ function hookListeners<T>(id: Entity<T>): void {
 		removedSignal.fire(entity);
 	});
 	registry.set(id, ecs.OnSet, (entity, data) => {
-		changedSignal.fire(entity, data as T);
+		changedSignal.fire(entity, data);
 	});
 }
 
@@ -75,11 +113,11 @@ function hookListeners<T>(id: Entity<T>): void {
  * @param key - Flamework autogenerated key.
  * @metadata macro
  */
-export function reserve<T>(runtimeId: Entity<T>, key?: Modding.Generic<T, "id">): void {
+export function reserve<T>(runtimeId: Entity<Unwrap<T>>, key?: ComponentKey<T>): void {
 	assert(key);
 	assert(!components.has(key), `A component with the key "${key}" already exists`);
 	components.set(key, runtimeId);
-	hookListeners<T>(runtimeId);
+	hookListeners(runtimeId);
 }
 
 /**
@@ -94,12 +132,12 @@ export function reserve<T>(runtimeId: Entity<T>, key?: Modding.Generic<T, "id">)
  * @returns The component entity ID.
  * @metadata macro
  */
-export function component<T>(key?: ComponentKey<T>): Entity<T> {
+export function component<T>(key?: ComponentKey<T>): Entity<Unwrap<T>> {
 	assert(key);
-	let id = components.get(key) as Entity<T> | undefined;
+	let id = components.get(key) as Entity<Unwrap<T>> | undefined;
 
 	if (id === undefined) {
-		id = registry.component<T>();
+		id = registry.component();
 		components.set(key, id);
 		hookListeners(id);
 	}
@@ -115,7 +153,7 @@ export function component<T>(key?: ComponentKey<T>): Entity<T> {
  * @returns The component or pair ID.
  * @metadata macro.
  */
-export function getId<T>(key?: ResolveKey<T>): Id<FilterPair<T>> {
+export function getId<T>(key?: ResolveKey<T>): Id<ResolveValue<T>> {
 	assert(key);
 
 	if (typeIs(key, "table")) {
@@ -130,24 +168,59 @@ export function getId<T>(key?: ResolveKey<T>): Id<FilterPair<T>> {
 }
 
 /**
- * Creates a new entity with the specified components.
+ * Creates a new empty entity.
+ *
+ * @returns The created entity.
+ * @metadata macro
+ */
+export function spawn(): ecs.Tag;
+
+/**
+ * Creates a new entity with the specified tag components.
+ *
+ * @template T - The type of the components.
+ * @param keys - Flamework autogenerated keys.
+ * @returns The created entity.
+ * @metadata macro
+ */
+export function spawn<T extends Array<Tag>>(keys?: ResolveKeys<T>): ecs.Tag;
+
+/**
+ * Creates a new entity with the specified components and their values.
  *
  * @template T - The type of the components.
- * @param bundle - The components to add to the entity.
+ * @param values - The values to set for the components.
  * @param keys - Flamework autogenerated keys.
  * @returns The created entity.
  * @metadata macro
  */
 export function spawn<T extends Array<unknown>>(
-	bundle?: FilterPairs<T>,
+	values: TrailingUndefined<ResolveValues<T>>,
 	keys?: ResolveKeys<T>,
-): Tag {
+): ecs.Tag;
+
+export function spawn<T extends Array<unknown>>(argument1?: unknown, argument2?: unknown): ecs.Tag {
 	const entity = registry.entity();
 
-	if (bundle && keys) {
+	if (argument2 !== undefined) {
+		// Spawn with components: spawn(values, keys)
+		const values = argument1 as TrailingUndefined<ResolveValues<T>>;
+		const keys = argument2 as ResolveKeys<T>;
+
 		for (let index = 0; index < keys.size(); index++) {
 			const id = getId(keys[index]);
-			registry.set(entity, id, bundle[index]);
+			const value = values[index];
+			if (value !== undefined) {
+				registry.set(entity, id, value);
+			} else {
+				registry.add(entity, id);
+			}
+		}
+	} else if (argument1 !== undefined) {
+		// Spawn with tags only: spawn(keys)
+		const keys = argument1 as ResolveKeys<T>;
+		for (const key of keys) {
+			registry.add(entity, getId(key));
 		}
 	}
 
@@ -163,6 +236,16 @@ export function despawn(entity: Entity): void {
 	registry.delete(entity);
 }
 
+/**
+ * Adds or updates multiple components for the specified entity.
+ *
+ * @template T - The type of the components.
+ * @param entity - The entity to modify.
+ * @param keys - Flamework autogenerated keys.
+ * @metadata macro
+ */
+export function insert<T extends Array<Tag>>(entity: Entity, keys?: ResolveKeys<T>): void;
+
 /**
  * Adds or updates multiple components for the specified entity.
  *
@@ -174,13 +257,36 @@ export function despawn(entity: Entity): void {
  */
 export function insert<T extends Array<unknown>>(
 	entity: Entity,
-	values: FilterPairs<T>,
+	values: TrailingUndefined<ResolveValues<T>>,
 	keys?: ResolveKeys<T>,
+): void;
+
+export function insert<T extends Array<unknown>>(
+	entity: Entity,
+	argument1?: unknown,
+	argument2?: unknown,
 ): void {
-	assert(keys);
-	for (let index = 0; index < keys.size(); index++) {
-		const id = getId(keys[index]);
-		registry.set(entity, id, values[index]);
+	assert(argument1 !== undefined);
+	if (argument2 !== undefined) {
+		// Insert components: insert(entity, values, keys)
+		const values = argument1 as TrailingUndefined<ResolveValues<T>>;
+		const keys = argument2 as ResolveKeys<T>;
+
+		for (let index = 0; index < keys.size(); index++) {
+			const id = getId(keys[index]);
+			const value = values[index];
+			if (value !== undefined) {
+				registry.set(entity, id, value);
+			} else {
+				registry.add(entity, id);
+			}
+		}
+	} else {
+		// Insert tags only: insert(entity, keys)
+		const keys = argument1 as ResolveKeys<T>;
+		for (const key of keys) {
+			registry.add(entity, getId(key));
+		}
 	}
 }
 
@@ -193,10 +299,10 @@ export function insert<T extends Array<unknown>>(
  * @param key - Flamework autogenerated key.
  * @metadata macro
  */
-export function add<T extends Pair<defined>>(
+export function add<T extends Pair<Tag>>(
 	entity: Entity,
 	object: Entity,
-	key?: ComponentKey<FilterPair<T>>,
+	key?: ComponentKey<ExtractPredicate<T>>,
 ): void;
 
 /**
@@ -208,7 +314,7 @@ export function add<T extends Pair<defined>>(
  * @param key - Flamework autogenerated key.
  * @metadata macro
  */
-export function add<T extends Pair<defined, defined>>(entity: Entity, key?: ResolveKey<T>): void;
+export function add<T extends Pair<Tag, defined>>(entity: Entity, key?: ResolveKey<T>): void;
 
 /**
  * Adds a component to an entity.
@@ -218,7 +324,7 @@ export function add<T extends Pair<defined, defined>>(entity: Entity, key?: Reso
  * @param key - Flamework autogenerated key.
  * @metadata macro
  */
-export function add<T>(entity: Entity, key?: ComponentKey<T>): void;
+export function add<T extends Tag>(entity: Entity, key?: ComponentKey<T>): void;
 
 export function add(entity: Entity, argument1?: unknown, argument2?: unknown): void {
 	if (argument2 !== undefined) {
@@ -245,7 +351,7 @@ export function add(entity: Entity, argument1?: unknown, argument2?: unknown): v
 export function remove<T extends Pair<defined>>(
 	entity: Entity,
 	object: Entity,
-	key?: ComponentKey<FilterPair<T>>,
+	key?: ComponentKey<ExtractPredicate<T>>,
 ): void;
 
 /**
@@ -295,8 +401,8 @@ export function remove(entity: Entity, argument1?: unknown, argument2?: unknown)
 export function set<T extends Pair<defined>>(
 	entity: Entity,
 	object: Entity,
-	value: FilterPair<T>,
-	key?: ComponentKey<FilterPair<T>>,
+	value: ResolveValue<T>,
+	key?: ComponentKey<ExtractPredicate<T>>,
 ): void;
 
 /**
@@ -311,7 +417,7 @@ export function set<T extends Pair<defined>>(
  */
 export function set<T extends Pair<defined, defined>>(
 	entity: Entity,
-	value: FilterPair<T>,
+	value: ResolveValue<T>,
 	key?: ResolveKey<T>,
 ): void;
 
@@ -324,7 +430,7 @@ export function set<T extends Pair<defined, defined>>(
  * @param key - Flamework autogenerated key.
  * @metadata macro
  */
-export function set<T>(entity: Entity, value: T, key?: ComponentKey<T>): void;
+export function set<T>(entity: Entity, value: Unwrap<T>, key?: ComponentKey<T>): void;
 
 export function set(
 	entity: Entity,
@@ -359,8 +465,8 @@ export function set(
 export function get<T extends Pair<defined>>(
 	entity: Entity,
 	object: Entity,
-	key?: ComponentKey<FilterPair<T>>,
-): FilterPair<T> | undefined;
+	key?: ComponentKey<ExtractPredicate<T>>,
+): ResolveValue<T> | undefined;
 
 /**
  * Retrieves the value of a component or pair for a specific entity.
@@ -371,7 +477,7 @@ export function get<T extends Pair<defined>>(
  * @returns The value associated with the component or pair.
  * @metadata macro
  */
-export function get<T>(entity: Entity, key?: ResolveKey<T>): FilterPair<T> | undefined;
+export function get<T>(entity: Entity, key?: ResolveKey<T>): ResolveValue<T> | undefined;
 
 export function get(entity: Entity, argument1?: unknown, argument2?: unknown): unknown {
 	if (argument2 !== undefined) {
@@ -399,7 +505,7 @@ export function get(entity: Entity, argument1?: unknown, argument2?: unknown): u
 export function has<T extends Pair<defined>>(
 	entity: Entity,
 	object: Entity,
-	key?: ComponentKey<FilterPair<T>>,
+	key?: ComponentKey<ExtractPredicate<T>>,
 ): boolean;
 
 /**
@@ -462,10 +568,23 @@ export function parent(entity: Entity): Entity | undefined {
  * @returns The pair ID.
  * @metadata macro
  */
-export function pair<P>(object: Entity, predicate?: ComponentKey<P>): Pair<P, unknown> {
+export function pair<P>(object: Entity, predicate?: ComponentKey<P>): Pair<Unwrap<P>, unknown> {
 	const predicateId = component(predicate);
 	return ecs.pair(predicateId, object);
 }
 
-reserve<Wildcard>(ecs.Wildcard as Entity<Wildcard>);
-reserve<ChildOf>(ecs.ChildOf as Entity<ChildOf>);
+/**
+ * Resets the ECS registry to its initial state. This should primarily be used
+ * for unit testing to ensure a clean state between tests.
+ */
+export function reset(): void {
+	const temporaryRegistry = new ecs.World();
+	for (const [key, value] of pairs(temporaryRegistry)) {
+		(registry as unknown as Record<string, unknown>)[key] = value;
+	}
+
+	components.clear();
+}
+
+reserve<Wildcard>(ecs.Wildcard as ecs.Tag);
+reserve<ChildOf>(ecs.ChildOf as ecs.Tag);