@voidhash/mimic-effect 1.0.0-beta.15 → 1.0.0-beta.17

package/package.json

@@ -1,52 +1,48 @@
 {
   "name": "@voidhash/mimic-effect",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/voidhashcom/mimic",
-    "directory": "packages/mimic-server-effect"
+    "url": "https://github.com/voidhashcom/voidhash",
+    "directory": "packages/mimic-effect"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "main": "./src/index.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.mts",
+      "types": "./src/index.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
     },
     "./testing": {
-      "types": "./dist/testing/index.d.mts",
+      "types": "./src/testing/index.ts",
       "import": "./dist/testing/index.mjs",
       "require": "./dist/testing/index.cjs"
     }
   },
   "devDependencies": {
-    "@effect/vitest": "^0.26.0",
+    "@effect/vitest": "4.0.0-beta.21",
     "tsdown": "^0.18.2",
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@voidhash/tsconfig": "1.0.0-beta.15"
+    "@voidhash/tsconfig": "1.0.0-beta.17"
   },
   "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.15"
-  },
-  "peerDependenciesMeta": {
-    "@effect/cluster": {
-      "optional": true
-    },
-    "@effect/rpc": {
-      "optional": true
-    }
+    "effect": "4.0.0-beta.21",
+    "@voidhash/mimic": "1.0.0-beta.17"
   },
   "scripts": {
     "build": "tsdown",
     "lint": "biome check .",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsgo --noEmit",
     "test": "vitest run -c vitest.mts"
   }
 }

package/src/ColdStorage.ts

@@ -3,7 +3,7 @@
  *
  * Interface and implementations for document snapshot storage.
  */
-import { Context, Effect, HashMap, Layer, Ref } from "effect";
+import { Effect, HashMap, Layer, Ref, ServiceMap } from "effect";
 import type { StoredDocument } from "./Types";
 import { ColdStorageError } from "./Errors";
 
@@ -50,10 +50,9 @@ export interface ColdStorage {
 /**
  * Context tag for ColdStorage service
  */
-export class ColdStorageTag extends Context.Tag("@voidhash/mimic-effect/ColdStorage")<
-  ColdStorageTag,
-  ColdStorage
->() {}
+export class ColdStorageTag extends ServiceMap.Service<ColdStorageTag, ColdStorage>()(
+  "@voidhash/mimic-effect/ColdStorage"
+) {}
 
 // =============================================================================
 // Factory

package/src/DocumentInstance.ts

@@ -186,11 +186,11 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
 
     // Track metrics
     if (storedDoc) {
-      yield* Metric.increment(Metrics.documentsRestored);
+      yield* Metric.update(Metrics.documentsRestored, 1);
     } else {
-      yield* Metric.increment(Metrics.documentsCreated);
+      yield* Metric.update(Metrics.documentsCreated, 1);
     }
-    yield* Metric.incrementBy(Metrics.documentsActive, 1);
+    yield* Metric.update(Metrics.documentsActive, 1);
 
     // ==========================================================================
     // Instance Methods
@@ -252,7 +252,7 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
 
       // Track snapshot metrics
       const snapshotDuration = Date.now() - snapshotStartTime;
-      yield* Metric.increment(Metrics.storageSnapshots);
+      yield* Metric.update(Metrics.storageSnapshots, 1);
       yield* Metric.update(Metrics.storageSnapshotLatency, snapshotDuration);
 
       // Update tracking BEFORE truncate (for idempotency on retry)
@@ -261,7 +261,7 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
       yield* Ref.set(transactionsSinceSnapshotRef, 0);
 
       // Truncate WAL - non-fatal, will be retried on next snapshot
-      yield* Effect.catchAll(hotStorage.truncate(documentId, snapshotResult.version), (e) =>
+      yield* Effect["catch"](hotStorage.truncate(documentId, snapshotResult.version), (e) =>
         Effect.logWarning("WAL truncate failed - will retry on next snapshot", {
           documentId,
           version: snapshotResult.version,
@@ -291,7 +291,7 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
       const validation = document.validate(transaction);
 
       if (!validation.valid) {
-        yield* Metric.increment(Metrics.transactionsRejected);
+        yield* Metric.update(Metrics.transactionsRejected, 1);
         const latency = Date.now() - submitStartTime;
         yield* Metric.update(Metrics.transactionsLatency, latency);
 
@@ -312,17 +312,17 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
       // This ensures correct validation after truncation or restart
       const snapshotVersion = yield* Ref.get(lastSnapshotVersionRef);
 
-      const appendResult = yield* Effect.either(
+      const appendResult = yield* Effect.result(
         hotStorage.appendWithCheck(documentId, walEntry, validation.nextVersion, snapshotVersion)
       );
 
-      if (appendResult._tag === "Left") {
+      if (appendResult._tag === "Failure") {
         yield* Effect.logError("WAL append failed", {
           documentId,
           version: validation.nextVersion,
-          error: appendResult.left,
+          error: appendResult.failure,
         });
-        yield* Metric.increment(Metrics.walAppendFailures);
+        yield* Metric.update(Metrics.walAppendFailures, 1);
 
         const latency = Date.now() - submitStartTime;
         yield* Metric.update(Metrics.transactionsLatency, latency);
@@ -339,8 +339,8 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
       // Track metrics
       const latency = Date.now() - submitStartTime;
       yield* Metric.update(Metrics.transactionsLatency, latency);
-      yield* Metric.increment(Metrics.transactionsProcessed);
-      yield* Metric.increment(Metrics.storageWalAppends);
+      yield* Metric.update(Metrics.transactionsProcessed, 1);
+      yield* Metric.update(Metrics.storageWalAppends, 1);
 
       // Increment transaction count
       yield* Ref.update(transactionsSinceSnapshotRef, (n) => n + 1);
@@ -425,7 +425,7 @@ const verifyWalContinuity = Effect.fn("document.wal.verify")(function* (
       firstWalVersion,
       expectedFirst,
     });
-    yield* Metric.increment(Metrics.storageVersionGaps);
+    yield* Metric.update(Metrics.storageVersionGaps, 1);
   }
 
   for (let i = 1; i < walEntries.length; i++) {

package/src/HotStorage.ts

@@ -3,7 +3,7 @@
  *
  * Interface and implementations for Write-Ahead Log (WAL) storage.
  */
-import { Context, Effect, HashMap, Layer, Ref } from "effect";
+import { Effect, HashMap, Layer, Ref, ServiceMap } from "effect";
 import type { WalEntry } from "./Types";
 import { HotStorageError, WalVersionGapError } from "./Errors";
 
@@ -79,10 +79,10 @@ export interface HotStorage {
 /**
  * Context tag for HotStorage service
  */
-export class HotStorageTag extends Context.Tag("@voidhash/mimic-effect/HotStorage")<
+export class HotStorageTag extends ServiceMap.Service<
   HotStorageTag,
   HotStorage
->() {}
+>()("@voidhash/mimic-effect/HotStorage") {}
 
 // =============================================================================
 // Factory

package/src/Metrics.ts

@@ -3,7 +3,7 @@
  *
  * Observability metrics using Effect's Metric API.
  */
-import { Metric, MetricBoundaries } from "effect";
+import { Metric } from "effect";
 
 // =============================================================================
 // Connection Metrics
@@ -24,11 +24,13 @@ export const connectionsTotal = Metric.counter("mimic.connections.total");
  */
 export const connectionsDuration = Metric.histogram(
   "mimic.connections.duration_ms",
-  MetricBoundaries.exponential({
-    start: 100,
-    factor: 2,
-    count: 15, // Up to ~3.2 million ms (~53 minutes)
-  })
+  {
+    boundaries: Metric.exponentialBoundaries({
+      start: 100,
+      factor: 2,
+      count: 15, // Up to ~3.2 million ms (~53 minutes)
+    }),
+  }
 );
 
 /**
@@ -83,11 +85,13 @@ export const transactionsRejected = Metric.counter(
  */
 export const transactionsLatency = Metric.histogram(
   "mimic.transactions.latency_ms",
-  MetricBoundaries.exponential({
-    start: 0.1,
-    factor: 2,
-    count: 15, // Up to ~1638 ms
-  })
+  {
+    boundaries: Metric.exponentialBoundaries({
+      start: 0.1,
+      factor: 2,
+      count: 15, // Up to ~1638 ms
+    }),
+  }
 );
 
 // =============================================================================
@@ -109,11 +113,13 @@ export const storageIdleSnapshots = Metric.counter("mimic.storage.idle_snapshots
  */
 export const storageSnapshotLatency = Metric.histogram(
   "mimic.storage.snapshot_latency_ms",
-  MetricBoundaries.exponential({
-    start: 1,
-    factor: 2,
-    count: 12, // Up to ~4 seconds
-  })
+  {
+    boundaries: Metric.exponentialBoundaries({
+      start: 1,
+      factor: 2,
+      count: 12, // Up to ~4 seconds
+    }),
+  }
 );
 
 /**

package/src/MimicAuthService.ts

@@ -3,7 +3,7 @@
  *
  * Authentication and authorization service interface and implementations.
  */
-import { Context, Effect, Layer } from "effect";
+import { Effect, Layer, ServiceMap } from "effect";
 import type { AuthContext, Permission } from "./Types";
 import { AuthenticationError } from "./Errors";
 
@@ -43,9 +43,9 @@ export interface MimicAuthService {
 /**
  * Context tag for MimicAuthService
  */
-export class MimicAuthServiceTag extends Context.Tag(
+export class MimicAuthServiceTag extends ServiceMap.Service<MimicAuthServiceTag, MimicAuthService>()(
   "@voidhash/mimic-effect/MimicAuthService"
-)<MimicAuthServiceTag, MimicAuthService>() {}
+) {}
 
 // =============================================================================
 // Factory

package/src/MimicClusterServerEngine.ts

@@ -7,7 +7,6 @@
  * This is an alternative to MimicServerEngine for distributed deployments.
  */
 import {
-  Context,
   Duration,
   Effect,
   HashMap,
@@ -17,10 +16,11 @@ import {
   Ref,
   Schedule,
   Schema,
+  ServiceMap,
   Stream,
 } from "effect";
-import { Entity, Sharding } from "@effect/cluster";
-import { Rpc } from "@effect/rpc";
+import { Entity, Sharding } from "effect/unstable/cluster";
+import { Rpc } from "effect/unstable/rpc";
 import { type Primitive, type Transaction } from "@voidhash/mimic";
 import type {
   MimicClusterServerEngineConfig,
@@ -59,13 +59,13 @@ const DEFAULT_SHARD_GROUP = "mimic-documents";
  */
 const EncodedTransactionSchema = Schema.Struct({
   id: Schema.String,
-  ops: Schema.Array(Schema.Unknown),
+  ops: Schema.Array(Schema.Any),
 });
 
 /**
  * Schema for submit result
  */
-const SubmitResultSchema = Schema.Union(
+const SubmitResultSchema = Schema.Union([
   Schema.Struct({
     success: Schema.Literal(true),
     version: Schema.Number,
@@ -73,14 +73,14 @@ const SubmitResultSchema = Schema.Union(
   Schema.Struct({
     success: Schema.Literal(false),
     reason: Schema.String,
-  })
-);
+  }),
+]);
 
 /**
  * Schema for snapshot response
  */
 const SnapshotResponseSchema = Schema.Struct({
-  state: Schema.Unknown,
+  state: Schema.Any,
   version: Schema.Number,
 });
 
@@ -88,7 +88,7 @@ const SnapshotResponseSchema = Schema.Struct({
  * Schema for presence entry
  */
 const PresenceEntrySchema = Schema.Struct({
-  data: Schema.Unknown,
+  data: Schema.Any,
   userId: Schema.optional(Schema.String),
 });
 
@@ -96,29 +96,29 @@ const PresenceEntrySchema = Schema.Struct({
  * Schema for presence snapshot response
  */
 const PresenceSnapshotResponseSchema = Schema.Struct({
-  presences: Schema.Record({ key: Schema.String, value: PresenceEntrySchema }),
+  presences: Schema.Record(Schema.String, PresenceEntrySchema),
 });
 
 /**
  * Schema for presence event
  */
-const PresenceEventSchema = Schema.Union(
+const PresenceEventSchema = Schema.Union([
   Schema.Struct({
     type: Schema.Literal("presence_update"),
     id: Schema.String,
-    data: Schema.Unknown,
+    data: Schema.Any,
     userId: Schema.optional(Schema.String),
   }),
   Schema.Struct({
     type: Schema.Literal("presence_remove"),
     id: Schema.String,
-  })
-);
+  }),
+]);
 
 /**
  * Schema for server message (for broadcasts)
  */
-const ServerMessageSchema = Schema.Unknown;
+const ServerMessageSchema = Schema.Any;
 
 // =============================================================================
 // Mimic Document Entity Definition
@@ -142,7 +142,7 @@ const MimicDocumentEntity = Entity.make("MimicDocument", [
 
   // Get tree-like snapshot for rendering
   Rpc.make("GetTreeSnapshot", {
-    success: Schema.Unknown,
+    success: Schema.Any,
   }),
 
   // Touch document to prevent idle GC
@@ -191,9 +191,9 @@ interface EntityState<TSchema extends Primitive.AnyPrimitive> {
 /**
  * Context tag for cluster engine configuration
  */
-class MimicClusterConfigTag extends Context.Tag(
+class MimicClusterConfigTag extends ServiceMap.Service<MimicClusterConfigTag, ResolvedClusterConfig<Primitive.AnyPrimitive>>()(
   "@voidhash/mimic-effect/MimicClusterConfig"
-)<MimicClusterConfigTag, ResolvedClusterConfig<Primitive.AnyPrimitive>>() {}
+) {}
 
 // =============================================================================
 // Resolve Configuration
@@ -206,18 +206,18 @@ const resolveClusterConfig = <TSchema extends Primitive.AnyPrimitive>(
   initial: config.initial,
   presence: config.presence,
   maxIdleTime: config.maxIdleTime
-    ? Duration.decode(config.maxIdleTime)
+    ? Duration.fromInputUnsafe(config.maxIdleTime)
     : DEFAULT_MAX_IDLE_TIME,
   maxTransactionHistory:
     config.maxTransactionHistory ?? DEFAULT_MAX_TRANSACTION_HISTORY,
   snapshot: {
     interval: config.snapshot?.interval
-      ? Duration.decode(config.snapshot.interval)
+      ? Duration.fromInputUnsafe(config.snapshot.interval)
       : DEFAULT_SNAPSHOT_INTERVAL,
     transactionThreshold:
       config.snapshot?.transactionThreshold ?? DEFAULT_SNAPSHOT_THRESHOLD,
     idleTimeout: config.snapshot?.idleTimeout
-      ? Duration.decode(config.snapshot.idleTimeout)
+      ? Duration.fromInputUnsafe(config.snapshot.idleTimeout)
       : DEFAULT_SNAPSHOT_IDLE_TIMEOUT,
   },
   shardGroup: config.shardGroup ?? DEFAULT_SHARD_GROUP,
@@ -290,14 +290,14 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
     yield* Effect.addFinalizer(() =>
       Effect.fn("cluster.entity.finalize")(function* () {
         // Best effort save - don't fail shutdown if storage is unavailable
-        yield* Effect.catchAll(instance.saveSnapshot(), (e) =>
+        yield* Effect["catch"](instance.saveSnapshot(), (e) =>
           Effect.logError("Failed to save snapshot during entity finalization", {
             documentId,
             error: e,
           })
         );
-        yield* Metric.incrementBy(Metrics.documentsActive, -1);
-        yield* Metric.increment(Metrics.documentsEvicted);
+        yield* Metric.update(Metrics.documentsActive, -1);
+        yield* Metric.update(Metrics.documentsEvicted, 1);
         yield* Effect.logDebug("Entity finalized", { documentId });
       })()
     );
@@ -308,20 +308,20 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
       const snapshotLoop = Effect.fn("cluster.entity.snapshot.loop")(function* () {
         const needs = yield* instance.needsSnapshot();
         if (needs) {
-          yield* Effect.catchAll(instance.saveSnapshot(), (e) =>
+          yield* Effect["catch"](instance.saveSnapshot(), (e) =>
             Effect.logWarning("Periodic snapshot failed in cluster entity", {
               documentId,
               error: e,
             })
           );
-          yield* Metric.increment(Metrics.storageIdleSnapshots);
+          yield* Metric.update(Metrics.storageIdleSnapshots, 1);
         }
       });
 
       // Run every idleTimeout
       yield* snapshotLoop().pipe(
         Effect.repeat(Schedule.spaced(config.snapshot.idleTimeout)),
-        Effect.fork
+        Effect.forkChild
       );
     }
 
@@ -335,7 +335,7 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
 
         // Use DocumentInstance's submit method, catching storage errors
         return yield* instance.submit(transaction).pipe(
-          Effect.catchAll((error) =>
+          Effect["catch"]((error) =>
             Effect.succeed({
               success: false as const,
               reason: `Storage error: ${String(error)}`,
@@ -364,8 +364,8 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
           presences: HashMap.set(s.presences, connectionId, entry),
         }));
 
-        yield* Metric.increment(Metrics.presenceUpdates);
-        yield* Metric.incrementBy(Metrics.presenceActive, 1);
+        yield* Metric.update(Metrics.presenceUpdates, 1);
+        yield* Metric.update(Metrics.presenceActive, 1);
 
         const state = yield* Ref.get(stateRef);
         const event: PresenceEvent = {
@@ -392,7 +392,7 @@ const createEntityHandler = <TSchema extends Primitive.AnyPrimitive>(
           presences: HashMap.remove(s.presences, connectionId),
         }));
 
-        yield* Metric.incrementBy(Metrics.presenceActive, -1);
+        yield* Metric.update(Metrics.presenceActive, -1);
 
         const event: PresenceEvent = {
           type: "presence_remove",
@@ -431,9 +431,9 @@ interface SubscriptionStore {
   ) => Effect.Effect<PubSub.PubSub<PresenceEvent>>;
 }
 
-class SubscriptionStoreTag extends Context.Tag(
+class SubscriptionStoreTag extends ServiceMap.Service<SubscriptionStoreTag, SubscriptionStore>()(
   "@voidhash/mimic-effect/SubscriptionStore"
-)<SubscriptionStoreTag, SubscriptionStore>() {}
+) {}
 
 const subscriptionStoreLayer = Layer.effect(
   SubscriptionStoreTag,
@@ -554,7 +554,7 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
   );
 
   // Create the engine service
-  const engineLayer = Layer.scoped(
+  const engineLayer = Layer.effect(
     MimicServerEngineTag,
     Effect.gen(function* () {
       // Get entity client maker
@@ -571,7 +571,7 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
             const result = yield* client.Submit({
               transaction: encodedTx as { id: string; ops: unknown[] },
             }).pipe(
-              Effect.catchAll((error) =>
+              Effect["catch"]((error) =>
                 Effect.succeed({
                   success: false as const,
                   reason: `Cluster error: ${String(error)}`,