@voidhash/mimic-effect 1.0.0-beta.5 → 1.0.0-beta.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidhash/mimic-effect",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.7",
   "type": "module",
   "repository": {
     "type": "git",
@@ -26,14 +26,14 @@
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@voidhash/tsconfig": "1.0.0-beta.5"
+    "@voidhash/tsconfig": "1.0.0-beta.7"
   },
   "peerDependencies": {
     "@effect/platform": "^0.93.8",
     "@effect/cluster": "^0.55.0",
     "@effect/rpc": "^0.72.2",
     "effect": "^3.19.12",
-    "@voidhash/mimic": "1.0.0-beta.5"
+    "@voidhash/mimic": "1.0.0-beta.7"
   },
   "peerDependenciesMeta": {
     "@effect/cluster": {

package/src/ColdStorage.ts

@@ -104,24 +104,33 @@ export namespace InMemory {
   export const make = (): Layer.Layer<ColdStorageTag> =>
     Layer.effect(
       ColdStorageTag,
-      Effect.gen(function* () {
+      Effect.fn("cold-storage.in-memory.create")(function* () {
         const store = yield* Ref.make(HashMap.empty<string, StoredDocument>());
 
         return {
-          load: (documentId) =>
-            Effect.gen(function* () {
-              const current = yield* Ref.get(store);
-              const result = HashMap.get(current, documentId);
-              return result._tag === "Some" ? result.value : undefined;
-            }),
+          load: Effect.fn("cold-storage.load")(function* (documentId: string) {
+            const current = yield* Ref.get(store);
+            const result = HashMap.get(current, documentId);
+            return result._tag === "Some" ? result.value : undefined;
+          }),
 
-          save: (documentId, document) =>
-            Ref.update(store, (map) => HashMap.set(map, documentId, document)),
+          save: Effect.fn("cold-storage.save")(
+            function* (documentId: string, document: StoredDocument) {
+              yield* Ref.update(store, (map) =>
+                HashMap.set(map, documentId, document)
+              );
+            }
+          ),
 
-          delete: (documentId) =>
-            Ref.update(store, (map) => HashMap.remove(map, documentId)),
+          delete: Effect.fn("cold-storage.delete")(
+            function* (documentId: string) {
+              yield* Ref.update(store, (map) =>
+                HashMap.remove(map, documentId)
+              );
+            }
+          ),
         };
-      })
+      })()
     );
 }
 

package/src/DocumentManager.ts

@@ -176,10 +176,8 @@ export const layer = Layer.scoped(
     /**
      * Restore a document from storage
      */
-    const restoreDocument = (
-      documentId: string
-    ): Effect.Effect<DocumentInstance<typeof config.schema>, ColdStorageError | HotStorageError> =>
-      Effect.gen(function* () {
+    const restoreDocument = Effect.fn("document.restore")(
+      function* (documentId: string) {
         // 1. Load snapshot from ColdStorage (errors propagate - do not silently fallback)
         const storedDoc = yield* coldStorage.load(documentId);
 
@@ -294,15 +292,14 @@ export const layer = Layer.scoped(
         yield* Metric.incrementBy(Metrics.documentsActive, 1);
 
         return instance;
-      });
+      }
+    );
 
     /**
      * Get or create a document instance
      */
-    const getOrCreateDocument = (
-      documentId: string
-    ): Effect.Effect<DocumentInstance<typeof config.schema>, ColdStorageError | HotStorageError> =>
-      Effect.gen(function* () {
+    const getOrCreateDocument = Effect.fn("document.get-or-create")(
+      function* (documentId: string) {
         const current = yield* Ref.get(store);
         const existing = HashMap.get(current, documentId);
 
@@ -321,7 +318,8 @@ export const layer = Layer.scoped(
         );
 
         return instance;
-      });
+      }
+    );
 
     /**
      * Save a snapshot to ColdStorage derived from WAL entries.
@@ -329,12 +327,12 @@ export const layer = Layer.scoped(
      * Idempotent: skips save if already snapshotted at target version.
      * Truncate failures are non-fatal and will be retried on next snapshot.
      */
-    const saveSnapshot = (
-      documentId: string,
-      instance: DocumentInstance<typeof config.schema>,
-      targetVersion: number
-    ): Effect.Effect<void, ColdStorageError | HotStorageError> =>
-      Effect.gen(function* () {
+    const saveSnapshot = Effect.fn("document.snapshot.save")(
+      function* (
+        documentId: string,
+        instance: DocumentInstance<typeof config.schema>,
+        targetVersion: number
+      ) {
         const lastSnapshotVersion = yield* Ref.get(instance.lastSnapshotVersion);
 
         // Idempotency check: skip if already snapshotted at this version
@@ -410,16 +408,17 @@ export const layer = Layer.scoped(
             error: e,
           })
         );
-      });
+      }
+    );
 
     /**
      * Check if snapshot should be triggered
      */
-    const checkSnapshotTriggers = (
-      documentId: string,
-      instance: DocumentInstance<typeof config.schema>
-    ): Effect.Effect<void, ColdStorageError | HotStorageError> =>
-      Effect.gen(function* () {
+    const checkSnapshotTriggers = Effect.fn("document.snapshot.check-triggers")(
+      function* (
+        documentId: string,
+        instance: DocumentInstance<typeof config.schema>
+      ) {
         const txCount = yield* Ref.get(instance.transactionsSinceSnapshot);
         const lastTime = yield* Ref.get(instance.lastSnapshotTime);
         const now = Date.now();
@@ -439,13 +438,14 @@ export const layer = Layer.scoped(
           yield* saveSnapshot(documentId, instance, currentVersion);
           return;
         }
-      });
+      }
+    );
 
     /**
      * Start background GC fiber
      */
-    const startGCFiber = Effect.gen(function* () {
-      const gcLoop = Effect.gen(function* () {
+    const startGCFiber = Effect.fn("document.gc.start")(function* () {
+      const gcLoop = Effect.fn("document.gc.loop")(function* () {
         const current = yield* Ref.get(store);
         const now = Date.now();
         const maxIdleMs = Duration.toMillis(config.maxIdleTime);
@@ -477,18 +477,18 @@ export const layer = Layer.scoped(
       });
 
       // Run GC every minute
-      yield* gcLoop.pipe(
+      yield* gcLoop().pipe(
         Effect.repeat(Schedule.spaced("1 minute")),
         Effect.fork
       );
     });
 
     // Start GC fiber
-    yield* startGCFiber;
+    yield* startGCFiber();
 
     // Cleanup on shutdown
     yield* Effect.addFinalizer(() =>
-      Effect.gen(function* () {
+      Effect.fn("document-manager.shutdown")(function* () {
         const current = yield* Ref.get(store);
         for (const [documentId, instance] of current) {
           // Best effort save - don't fail shutdown if storage is unavailable
@@ -501,12 +501,12 @@ export const layer = Layer.scoped(
           );
         }
         yield* Effect.logInfo("DocumentManager shutdown complete");
-      })
+      })()
     );
 
     return {
-      submit: (documentId, transaction) =>
-        Effect.gen(function* () {
+      submit: Effect.fn("document.transaction.submit")(
+        function* (documentId: string, transaction: Transaction.Transaction) {
           const instance = yield* getOrCreateDocument(documentId);
           const submitStartTime = Date.now();
 
@@ -577,28 +577,30 @@ export const layer = Layer.scoped(
             success: true as const,
             version: validation.nextVersion,
           };
-        }),
+        }
+      ),
 
-      getSnapshot: (documentId) =>
-        Effect.gen(function* () {
+      getSnapshot: Effect.fn("document.snapshot.get")(
+        function* (documentId: string) {
           const instance = yield* getOrCreateDocument(documentId);
           return instance.document.getSnapshot();
-        }),
+        }
+      ),
 
-      subscribe: (documentId) =>
-        Effect.gen(function* () {
+      subscribe: Effect.fn("document.subscribe")(
+        function* (documentId: string) {
           const instance = yield* getOrCreateDocument(documentId);
           return Stream.fromPubSub(instance.pubsub);
-        }),
-
-      touch: (documentId) =>
-        Effect.gen(function* () {
-          const current = yield* Ref.get(store);
-          const existing = HashMap.get(current, documentId);
-          if (existing._tag === "Some") {
-            yield* Ref.set(existing.value.lastActivityTime, Date.now());
-          }
-        }),
+        }
+      ),
+
+      touch: Effect.fn("document.touch")(function* (documentId: string) {
+        const current = yield* Ref.get(store);
+        const existing = HashMap.get(current, documentId);
+        if (existing._tag === "Some") {
+          yield* Ref.set(existing.value.lastActivityTime, Date.now());
+        }
+      }),
     };
   })
 );

package/src/HotStorage.ts

@@ -136,59 +136,71 @@ export namespace InMemory {
   export const make = (): Layer.Layer<HotStorageTag> =>
     Layer.effect(
       HotStorageTag,
-      Effect.gen(function* () {
+      Effect.fn("hot-storage.in-memory.create")(function* () {
         const store = yield* Ref.make(HashMap.empty<string, WalEntry[]>());
 
         return {
-          append: (documentId, entry) =>
-            Ref.update(store, (map) => {
-              const existing = HashMap.get(map, documentId);
-              const entries =
-                existing._tag === "Some" ? existing.value : [];
-              return HashMap.set(map, documentId, [...entries, entry]);
-            }),
+          append: Effect.fn("hot-storage.append")(
+            function* (documentId: string, entry: WalEntry) {
+              yield* Ref.update(store, (map) => {
+                const existing = HashMap.get(map, documentId);
+                const entries =
+                  existing._tag === "Some" ? existing.value : [];
+                return HashMap.set(map, documentId, [...entries, entry]);
+              });
+            }
+          ),
 
-          appendWithCheck: (documentId, entry, expectedVersion) =>
-            Effect.gen(function* () {
+          appendWithCheck: Effect.fn("hot-storage.append-with-check")(
+            function* (
+              documentId: string,
+              entry: WalEntry,
+              expectedVersion: number
+            ) {
               type CheckResult =
                 | { type: "ok" }
                 | { type: "gap"; lastVersion: number | undefined };
 
               // Use Ref.modify for atomic check + update
-              const result: CheckResult = yield* Ref.modify(store, (map): [CheckResult, HashMap.HashMap<string, WalEntry[]>] => {
-                const existing = HashMap.get(map, documentId);
-                const entries = existing._tag === "Some" ? existing.value : [];
-
-                // Find the highest version in existing entries
-                const lastVersion = entries.length > 0
-                  ? Math.max(...entries.map((e) => e.version))
-                  : 0;
-
-                // Gap check
-                if (expectedVersion === 1) {
-                  // First entry: should have no entries with version >= 1
-                  if (lastVersion >= 1) {
-                    return [
-                      { type: "gap", lastVersion },
-                      map,
-                    ];
-                  }
-                } else {
-                  // Not first: last entry should have version = expectedVersion - 1
-                  if (lastVersion !== expectedVersion - 1) {
-                    return [
-                      { type: "gap", lastVersion: lastVersion > 0 ? lastVersion : undefined },
-                      map,
-                    ];
+              const result: CheckResult = yield* Ref.modify(
+                store,
+                (map): [CheckResult, HashMap.HashMap<string, WalEntry[]>] => {
+                  const existing = HashMap.get(map, documentId);
+                  const entries =
+                    existing._tag === "Some" ? existing.value : [];
+
+                  // Find the highest version in existing entries
+                  const lastVersion =
+                    entries.length > 0
+                      ? Math.max(...entries.map((e) => e.version))
+                      : 0;
+
+                  // Gap check
+                  if (expectedVersion === 1) {
+                    // First entry: should have no entries with version >= 1
+                    if (lastVersion >= 1) {
+                      return [{ type: "gap", lastVersion }, map];
+                    }
+                  } else {
+                    // Not first: last entry should have version = expectedVersion - 1
+                    if (lastVersion !== expectedVersion - 1) {
+                      return [
+                        {
+                          type: "gap",
+                          lastVersion: lastVersion > 0 ? lastVersion : undefined,
+                        },
+                        map,
+                      ];
+                    }
                   }
-                }
 
-                // No gap: append and return success
-                return [
-                  { type: "ok" },
-                  HashMap.set(map, documentId, [...entries, entry]),
-                ];
-              });
+                  // No gap: append and return success
+                  return [
+                    { type: "ok" },
+                    HashMap.set(map, documentId, [...entries, entry]),
+                  ];
+                }
+              );
 
               if (result.type === "gap") {
                 return yield* Effect.fail(
@@ -199,10 +211,11 @@ export namespace InMemory {
                   })
                 );
               }
-            }),
+            }
+          ),
 
-          getEntries: (documentId, sinceVersion) =>
-            Effect.gen(function* () {
+          getEntries: Effect.fn("hot-storage.get-entries")(
+            function* (documentId: string, sinceVersion: number) {
               const current = yield* Ref.get(store);
               const existing = HashMap.get(current, documentId);
               const entries =
@@ -210,21 +223,25 @@ export namespace InMemory {
               return entries
                 .filter((e) => e.version > sinceVersion)
                 .sort((a, b) => a.version - b.version);
-            }),
+            }
+          ),
 
-          truncate: (documentId, upToVersion) =>
-            Ref.update(store, (map) => {
-              const existing = HashMap.get(map, documentId);
-              if (existing._tag === "None") {
-                return map;
-              }
-              const filtered = existing.value.filter(
-                (e) => e.version > upToVersion
-              );
-              return HashMap.set(map, documentId, filtered);
-            }),
+          truncate: Effect.fn("hot-storage.truncate")(
+            function* (documentId: string, upToVersion: number) {
+              yield* Ref.update(store, (map) => {
+                const existing = HashMap.get(map, documentId);
+                if (existing._tag === "None") {
+                  return map;
+                }
+                const filtered = existing.value.filter(
+                  (e) => e.version > upToVersion
+                );
+                return HashMap.set(map, documentId, filtered);
+              });
+            }
+          ),
         };
-      })
+      })()
     );
 }
 

package/src/MimicClusterServerEngine.ts

@@ -257,7 +257,7 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
   coldStorage: ColdStorage,
   hotStorage: HotStorage
 ) =>
-  Effect.gen(function* () {
+  Effect.fn("cluster.entity.handler.create")(function* () {
     // Get entity address to determine documentId
     const address = yield* Entity.CurrentAddress;
     const documentId = address.entityId;
@@ -406,7 +406,8 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
      * Idempotent: skips save if already snapshotted at target version.
      * Truncate failures are non-fatal and will be retried on next snapshot.
      */
-    const saveSnapshot = (targetVersion: number) => Effect.gen(function* () {
+    const saveSnapshot = Effect.fn("cluster.document.snapshot.save")(
+      function* (targetVersion: number) {
       const state = yield* Ref.get(stateRef);
 
       // Idempotency check: skip if already snapshotted at this version
@@ -504,12 +505,15 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
           error: e,
         })
       );
-    });
+      }
+    );
 
     /**
      * Check if snapshot should be triggered
      */
-    const checkSnapshotTriggers = Effect.gen(function* () {
+    const checkSnapshotTriggers = Effect.fn(
+      "cluster.document.snapshot.check-triggers"
+    )(function* () {
       const state = yield* Ref.get(stateRef);
       const now = Date.now();
       const currentVersion = state.document.getVersion();
@@ -530,7 +534,7 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
 
     // Cleanup on entity finalization
     yield* Effect.addFinalizer(() =>
-      Effect.gen(function* () {
+      Effect.fn("cluster.entity.finalize")(function* () {
         // Save final snapshot before entity is garbage collected
         const state = yield* Ref.get(stateRef);
         const currentVersion = state.document.getVersion();
@@ -538,12 +542,14 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
         yield* Metric.incrementBy(Metrics.documentsActive, -1);
         yield* Metric.increment(Metrics.documentsEvicted);
         yield* Effect.logDebug("Entity finalized", { documentId });
-      })
+      })()
     );
 
     // Return RPC handlers
     return {
-      Submit: Effect.fnUntraced(function* ({ payload }) {
+      Submit: Effect.fn("cluster.document.transaction.submit")(function* ({
+        payload,
+      }) {
         const submitStartTime = Date.now();
         const state = yield* Ref.get(stateRef);
 
@@ -611,7 +617,7 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
         }));
 
         // Check snapshot triggers
-        yield* checkSnapshotTriggers;
+        yield* checkSnapshotTriggers();
 
         return {
           success: true as const,
@@ -619,18 +625,18 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
         };
       }),
 
-      GetSnapshot: Effect.fnUntraced(function* () {
+      GetSnapshot: Effect.fn("cluster.document.snapshot.get")(function* () {
         const state = yield* Ref.get(stateRef);
         return state.document.getSnapshot();
       }),
 
-      Touch: Effect.fnUntraced(function* () {
+      Touch: Effect.fn("cluster.document.touch")(function* () {
         // Entity touch is handled automatically by the cluster framework
         // Just update last activity time conceptually
         return void 0;
       }),
 
-      SetPresence: Effect.fnUntraced(function* ({ payload }) {
+      SetPresence: Effect.fn("cluster.presence.set")(function* ({ payload }) {
         const { connectionId, entry } = payload;
 
         yield* Ref.update(stateRef, (s) => ({
@@ -651,7 +657,9 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
         yield* PubSub.publish(state.presencePubSub, event);
       }),
 
-      RemovePresence: Effect.fnUntraced(function* ({ payload }) {
+      RemovePresence: Effect.fn("cluster.presence.remove")(function* ({
+        payload,
+      }) {
         const { connectionId } = payload;
         const state = yield* Ref.get(stateRef);
 
@@ -673,16 +681,18 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
         yield* PubSub.publish(state.presencePubSub, event);
       }),
 
-      GetPresenceSnapshot: Effect.fnUntraced(function* () {
-        const state = yield* Ref.get(stateRef);
-        const presences: Record<string, PresenceEntry> = {};
-        for (const [id, entry] of state.presences) {
-          presences[id] = entry;
+      GetPresenceSnapshot: Effect.fn("cluster.presence.snapshot.get")(
+        function* () {
+          const state = yield* Ref.get(stateRef);
+          const presences: Record<string, PresenceEntry> = {};
+          for (const [id, entry] of state.presences) {
+            presences[id] = entry;
+          }
+          return { presences };
         }
-        return { presences };
-      }),
+      ),
     };
-  });
+  })();
 
 // =============================================================================
 // Subscription Store (for managing subscriptions at the gateway level)
@@ -707,7 +717,7 @@ class SubscriptionStoreTag extends Context.Tag(
 
 const subscriptionStoreLayer = Layer.effect(
   SubscriptionStoreTag,
-  Effect.gen(function* () {
+  Effect.fn("cluster.subscriptions.layer.create")(function* () {
     const documentPubSubs = yield* Ref.make(
       HashMap.empty<string, PubSub.PubSub<Protocol.ServerMessage>>()
     );
@@ -716,37 +726,39 @@ const subscriptionStoreLayer = Layer.effect(
     );
 
     return {
-      getOrCreatePubSub: (documentId: string) =>
-        Effect.gen(function* () {
-          const current = yield* Ref.get(documentPubSubs);
-          const existing = HashMap.get(current, documentId);
-          if (existing._tag === "Some") {
-            return existing.value;
-          }
+      getOrCreatePubSub: Effect.fn(
+        "cluster.subscriptions.pubsub.get-or-create"
+      )(function* (documentId: string) {
+        const current = yield* Ref.get(documentPubSubs);
+        const existing = HashMap.get(current, documentId);
+        if (existing._tag === "Some") {
+          return existing.value;
+        }
 
-          const pubsub = yield* PubSub.unbounded<Protocol.ServerMessage>();
-          yield* Ref.update(documentPubSubs, (map) =>
-            HashMap.set(map, documentId, pubsub)
-          );
-          return pubsub;
-        }),
-
-      getOrCreatePresencePubSub: (documentId: string) =>
-        Effect.gen(function* () {
-          const current = yield* Ref.get(presencePubSubs);
-          const existing = HashMap.get(current, documentId);
-          if (existing._tag === "Some") {
-            return existing.value;
-          }
+        const pubsub = yield* PubSub.unbounded<Protocol.ServerMessage>();
+        yield* Ref.update(documentPubSubs, (map) =>
+          HashMap.set(map, documentId, pubsub)
+        );
+        return pubsub;
+      }),
+
+      getOrCreatePresencePubSub: Effect.fn(
+        "cluster.subscriptions.presence-pubsub.get-or-create"
+      )(function* (documentId: string) {
+        const current = yield* Ref.get(presencePubSubs);
+        const existing = HashMap.get(current, documentId);
+        if (existing._tag === "Some") {
+          return existing.value;
+        }
 
-          const pubsub = yield* PubSub.unbounded<PresenceEvent>();
-          yield* Ref.update(presencePubSubs, (map) =>
-            HashMap.set(map, documentId, pubsub)
-          );
-          return pubsub;
-        }),
+        const pubsub = yield* PubSub.unbounded<PresenceEvent>();
+        yield* Ref.update(presencePubSubs, (map) =>
+          HashMap.set(map, documentId, pubsub)
+        );
+        return pubsub;
+      }),
     };
-  })
+  })()
 );
 
 // =============================================================================