refactor: consolidate internal utilities, flatten test structure

- Delete dead code: fiber-storage.ts (never imported)
- Merge is-effect, constants, get-tag, types into utils.ts
- Merge namespace.ts into machine.ts
- Rename machine-schema.ts → schema.ts
- Flatten test/features/ to test/
- Move transition-index.test.ts to test/internal/
- Update CODEMAP.md to reflect new structure

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: cevr

AGENTS.md

@@ -45,7 +45,6 @@ const machine = Machine.make({ state, event, initial })
 - Actor testing needs `Effect.yieldNow()` after `send()` to let effects run
 - Same-state transitions skip spawn/finalizers by default
 - `.reenter()` runs exit/enter even on same state tag - use to restart timers/spawn
-- `namespace.ts` exports Machine namespace (not `Machine.ts` - macOS case-insensitivity)
 - Branded types: `State<T>` / `Event<T>` prevent accidental swap at compile time
 - Brand is phantom (type-level only) - runtime values identical to `Data.TaggedEnum`
 - Schemas attached to machine: `persist` and `toEntity` infer schemas automatically

CODEMAP.md

@@ -5,9 +5,8 @@
 ```
 src/
 ├── index.ts              # Public exports
-├── namespace.ts          # Machine namespace (Effect-style API)
-├── machine-schema.ts     # Schema-first State/Event (MachineStateSchema, MachineEventSchema)
-├── machine.ts            # Machine class with fluent builder API
+├── machine.ts            # Machine class + namespace (fluent builder API)
+├── schema.ts             # Schema-first State/Event (MachineStateSchema, MachineEventSchema)
 ├── slot.ts               # Slot.Guards/Slot.Effects factories for parameterized slots
 ├── actor-ref.ts          # Actor reference interface
 ├── actor-system.ts       # Actor system service + layer
@@ -26,30 +25,27 @@ src/
     ├── loop.ts              # Event loop, transition resolver, lifecycle effects
     ├── execute-transition.ts # Shared transition execution (loop, simulate, harness)
     ├── transition-index.ts  # O(1) lookup for transitions
-    ├── fiber-storage.ts     # Per-actor WeakMap fiber storage utility
     ├── brands.ts            # StateBrand/EventBrand + BrandedState/BrandedEvent
-    ├── types.ts             # Internal utility types
-    ├── is-effect.ts         # Shared isEffect type guard
-    └── get-tag.ts           # Tag extraction from constructors
+    └── utils.ts             # Type helpers, constants, isEffect, getTag
 
 test/
 ├── machine.test.ts       # Core machine tests
 ├── actor-system.test.ts  # Actor spawning/lifecycle
 ├── actor-ref.test.ts     # ActorRef ergonomics
 ├── persistence.test.ts   # Persistence tests
 ├── testing.test.ts       # Test utilities
-├── machine-schema.test.ts # Schema-first State/Event tests
-├── transition-index.test.ts # O(1) transition lookup tests
+├── schema.test.ts        # Schema-first State/Event tests
 ├── inspection.test.ts    # Inspector tests
-├── features/             # Feature-specific tests
-│   ├── any.test.ts
-│   ├── delay.test.ts         # Timeout via spawn patterns
-│   ├── dynamic-delay.test.ts # Dynamic timeout via spawn
-│   ├── effects.test.ts
-│   ├── force.test.ts         # reenter transition tests
-│   ├── from.test.ts
-│   ├── guards.test.ts
-│   └── same-state.test.ts
+├── guards.test.ts        # Parameterized guard tests
+├── choose.test.ts        # Conditional transition tests
+├── delay.test.ts         # Timeout via spawn patterns
+├── dynamic-delay.test.ts # Dynamic timeout via spawn
+├── same-state.test.ts    # Same-state transition tests
+├── force.test.ts         # reenter transition tests
+├── utils/
+│   └── effect-test.ts    # Test helpers (yieldFibers, etc.)
+├── internal/
+│   └── transition-index.test.ts # O(1) transition lookup tests
 ├── patterns/             # Real-world pattern tests
 │   ├── payment-flow.test.ts
 │   ├── session-lifecycle.test.ts
@@ -63,14 +59,13 @@ test/
 
 | File                                | Purpose                                                     |
 | ----------------------------------- | ----------------------------------------------------------- |
-| `machine.ts`                        | Machine class - fluent builder, all combinators as methods  |
-| `machine-schema.ts`                 | Schema-first `State`/`Event` - single source of truth       |
+| `machine.ts`                        | Machine class + namespace - fluent builder, all combinators |
+| `schema.ts`                         | Schema-first `State`/`Event` - single source of truth       |
 | `slot.ts`                           | `Slot.Guards`/`Slot.Effects` - parameterized slot factories |
-| `namespace.ts`                      | Machine namespace export (named for macOS compat)           |
 | `internal/loop.ts`                  | Event processing, `resolveTransition`, spawn effect forking |
 | `internal/transition-index.ts`      | O(1) lookup for transitions                                 |
 | `internal/brands.ts`                | Branded types: `StateBrand`, `BrandedState`, etc.           |
-| `internal/fiber-storage.ts`         | `createFiberStorage()` - per-actor WeakMap utility          |
+| `internal/utils.ts`                 | Shared utilities: types, constants, `isEffect`, `getTag`    |
 | `persistence/persistent-machine.ts` | `Machine.persist` - schemas from machine                    |
 | `cluster/entity-machine.ts`         | `toEntity` - schemas from machine                           |
 
@@ -172,18 +167,6 @@ const MyEffects = Slot.Effects({
 - Context (`ctx`) has `{ state, event, self }`
 - `provide()` creates new machine - original reusable with different handlers
 
-## Fiber Storage Pattern
-
-`spawn` uses shared utility from `internal/fiber-storage.ts`:
-
-```ts
-import { createFiberStorage } from "../internal/fiber-storage.js";
-
-const getFiberMap = createFiberStorage(); // WeakMap-backed, per-actor
-const instanceKey = Symbol("spawn"); // unique per combinator instance
-getFiberMap(self).set(instanceKey, fiber);
-```
-
 ## Transition Index
 
 `internal/transition-index.ts` provides O(1) lookup via lazy-built WeakMap cache:

src/cluster/entity-machine.ts

@@ -10,8 +10,7 @@ import { Effect, Exit, type Layer, Queue, Ref, Scope } from "effect";
 import type { Machine, MachineRef, HandlerContext } from "../machine.js";
 import { resolveTransition, runSpawnEffects } from "../internal/loop.js";
 import type { GuardsDef, EffectsDef, MachineContext } from "../slot.js";
-import { isEffect } from "../internal/is-effect.js";
-import { INTERNAL_ENTER_EVENT } from "../internal/constants.js";
+import { isEffect, INTERNAL_ENTER_EVENT } from "../internal/utils.js";
 
 /**
  * Options for EntityMachine.layer

src/index.ts

@@ -1,5 +1,5 @@
 // Machine namespace (Effect-style)
-export * as Machine from "./namespace.js";
+export * as Machine from "./machine.js";
 
 // Slot module
 export { Slot } from "./slot.js";
@@ -30,8 +30,8 @@ export {
 } from "./errors.js";
 
 // Schema-first State/Event definitions
-export { State, Event } from "./machine-schema.js";
-export type { MachineStateSchema, MachineEventSchema } from "./machine-schema.js";
+export { State, Event } from "./schema.js";
+export type { MachineStateSchema, MachineEventSchema } from "./schema.js";
 
 // Core machine types (for advanced use)
 export type {

src/internal/constants.ts

@@ -8,7 +8,7 @@ import { Effect } from "effect";
 import type { Machine, MachineRef, HandlerContext } from "../machine.js";
 import type { GuardsDef, EffectsDef, MachineContext } from "../slot.js";
 import { resolveTransition } from "./loop.js";
-import { isEffect } from "./is-effect.js";
+import { isEffect } from "./utils.js";
 
 /**
  * Result of executing a transition.

src/internal/execute-transition.ts

@@ -7,7 +7,7 @@ import { Inspector as InspectorTag } from "../inspection.js";
 import { findTransitions, findSpawnEffects } from "./transition-index.js";
 import type { GuardsDef, EffectsDef, MachineContext } from "../slot.js";
 import { executeTransition } from "./execute-transition.js";
-import { INTERNAL_INIT_EVENT, INTERNAL_ENTER_EVENT } from "./constants.js";
+import { INTERNAL_INIT_EVENT, INTERNAL_ENTER_EVENT } from "./utils.js";
 
 /** Listener set for sync subscriptions */
 type Listeners<S> = Set<(state: S) => void>;