@voidhash/mimic-effect 0.0.2 → 0.0.4

package/dist/storage/InMemoryDataStorage.cjs

@@ -0,0 +1,57 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_MimicDataStorage = require('../MimicDataStorage.cjs');
+let effect_Effect = require("effect/Effect");
+effect_Effect = require_rolldown_runtime.__toESM(effect_Effect);
+let effect_Layer = require("effect/Layer");
+effect_Layer = require_rolldown_runtime.__toESM(effect_Layer);
+let effect_Ref = require("effect/Ref");
+effect_Ref = require_rolldown_runtime.__toESM(effect_Ref);
+let effect_HashMap = require("effect/HashMap");
+effect_HashMap = require_rolldown_runtime.__toESM(effect_HashMap);
+
+//#region src/storage/InMemoryDataStorage.ts
+/**
+* @since 0.0.1
+* In-memory data storage implementation for Mimic documents.
+* Provides ephemeral storage - data is lost when the server restarts.
+*/
+var InMemoryDataStorage_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	layer: () => layer,
+	layerDefault: () => layerDefault
+});
+/**
+* Create an in-memory storage service.
+* Uses a HashMap to store documents in memory.
+*/
+const makeInMemoryStorage = effect_Effect.gen(function* () {
+	const store = yield* effect_Ref.make(effect_HashMap.empty());
+	return {
+		load: (documentId) => effect_Effect.gen(function* () {
+			const current = yield* effect_Ref.get(store);
+			const result = effect_HashMap.get(current, documentId);
+			return result._tag === "Some" ? result.value : void 0;
+		}),
+		save: (documentId, state) => effect_Ref.update(store, (map) => effect_HashMap.set(map, documentId, state)),
+		delete: (documentId) => effect_Ref.update(store, (map) => effect_HashMap.remove(map, documentId)),
+		onLoad: (state) => effect_Effect.succeed(state),
+		onSave: (state) => effect_Effect.succeed(state)
+	};
+});
+/**
+* Layer that provides in-memory data storage.
+* This is the default storage implementation - ephemeral and non-persistent.
+*/
+const layer = effect_Layer.effect(require_MimicDataStorage.MimicDataStorageTag, makeInMemoryStorage);
+/**
+* Default layer alias for convenience.
+*/
+const layerDefault = layer;
+
+//#endregion
+Object.defineProperty(exports, 'InMemoryDataStorage_exports', {
+  enumerable: true,
+  get: function () {
+    return InMemoryDataStorage_exports;
+  }
+});
+exports.layerDefault = layerDefault;

package/dist/storage/InMemoryDataStorage.d.cts

@@ -0,0 +1,19 @@
+import { MimicDataStorageTag } from "../MimicDataStorage.cjs";
+import * as Layer from "effect/Layer";
+
+//#region src/storage/InMemoryDataStorage.d.ts
+declare namespace InMemoryDataStorage_d_exports {
+  export { layer, layerDefault };
+}
+/**
+ * Layer that provides in-memory data storage.
+ * This is the default storage implementation - ephemeral and non-persistent.
+ */
+declare const layer: Layer.Layer<MimicDataStorageTag>;
+/**
+ * Default layer alias for convenience.
+ */
+declare const layerDefault: Layer.Layer<MimicDataStorageTag, never, never>;
+//#endregion
+export { InMemoryDataStorage_d_exports };
+//# sourceMappingURL=InMemoryDataStorage.d.cts.map

package/dist/storage/InMemoryDataStorage.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryDataStorage.d.cts","names":[],"sources":["../../src/storage/InMemoryDataStorage.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;cAyDa,OAAO,KAAA,CAAM,MAAM;;;AAAhC;AAQa,cAAA,YAAY,EAAA,KAAA,CAAA,KAAA,CAAA,mBAAA,EAAA,KAAA,EAAA,KAAA,CAAA"}

package/dist/storage/InMemoryDataStorage.d.mts

@@ -0,0 +1,19 @@
+import { MimicDataStorageTag } from "../MimicDataStorage.mjs";
+import * as Layer from "effect/Layer";
+
+//#region src/storage/InMemoryDataStorage.d.ts
+declare namespace InMemoryDataStorage_d_exports {
+  export { layer, layerDefault };
+}
+/**
+ * Layer that provides in-memory data storage.
+ * This is the default storage implementation - ephemeral and non-persistent.
+ */
+declare const layer: Layer.Layer<MimicDataStorageTag>;
+/**
+ * Default layer alias for convenience.
+ */
+declare const layerDefault: Layer.Layer<MimicDataStorageTag, never, never>;
+//#endregion
+export { InMemoryDataStorage_d_exports };
+//# sourceMappingURL=InMemoryDataStorage.d.mts.map

package/dist/storage/InMemoryDataStorage.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryDataStorage.d.mts","names":[],"sources":["../../src/storage/InMemoryDataStorage.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;cAyDa,OAAO,KAAA,CAAM,MAAM;;;AAAhC;AAQa,cAAA,YAAY,EAAA,KAAA,CAAA,KAAA,CAAA,mBAAA,EAAA,KAAA,EAAA,KAAA,CAAA"}

package/dist/storage/InMemoryDataStorage.mjs

@@ -0,0 +1,48 @@
+import { __export } from "../_virtual/rolldown_runtime.mjs";
+import { MimicDataStorageTag } from "../MimicDataStorage.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Ref from "effect/Ref";
+import * as HashMap from "effect/HashMap";
+
+//#region src/storage/InMemoryDataStorage.ts
+/**
+* @since 0.0.1
+* In-memory data storage implementation for Mimic documents.
+* Provides ephemeral storage - data is lost when the server restarts.
+*/
+var InMemoryDataStorage_exports = /* @__PURE__ */ __export({
+	layer: () => layer,
+	layerDefault: () => layerDefault
+});
+/**
+* Create an in-memory storage service.
+* Uses a HashMap to store documents in memory.
+*/
+const makeInMemoryStorage = Effect.gen(function* () {
+	const store = yield* Ref.make(HashMap.empty());
+	return {
+		load: (documentId) => Effect.gen(function* () {
+			const current = yield* Ref.get(store);
+			const result = HashMap.get(current, documentId);
+			return result._tag === "Some" ? result.value : void 0;
+		}),
+		save: (documentId, state) => Ref.update(store, (map) => HashMap.set(map, documentId, state)),
+		delete: (documentId) => Ref.update(store, (map) => HashMap.remove(map, documentId)),
+		onLoad: (state) => Effect.succeed(state),
+		onSave: (state) => Effect.succeed(state)
+	};
+});
+/**
+* Layer that provides in-memory data storage.
+* This is the default storage implementation - ephemeral and non-persistent.
+*/
+const layer = Layer.effect(MimicDataStorageTag, makeInMemoryStorage);
+/**
+* Default layer alias for convenience.
+*/
+const layerDefault = layer;
+
+//#endregion
+export { InMemoryDataStorage_exports, layerDefault };
+//# sourceMappingURL=InMemoryDataStorage.mjs.map

package/dist/storage/InMemoryDataStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"InMemoryDataStorage.mjs","names":["layer: Layer.Layer<MimicDataStorageTag>"],"sources":["../../src/storage/InMemoryDataStorage.ts"],"sourcesContent":["/**\n * @since 0.0.1\n * In-memory data storage implementation for Mimic documents.\n * Provides ephemeral storage - data is lost when the server restarts.\n */\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport * as Ref from \"effect/Ref\";\nimport * as HashMap from \"effect/HashMap\";\n\nimport {\n  MimicDataStorageTag,\n  type MimicDataStorage,\n} from \"../MimicDataStorage.js\";\n\n// =============================================================================\n// In-Memory Storage Implementation\n// =============================================================================\n\n/**\n * Create an in-memory storage service.\n * Uses a HashMap to store documents in memory.\n */\nconst makeInMemoryStorage = Effect.gen(function* () {\n  // Create a mutable reference to a HashMap for storing documents\n  const store = yield* Ref.make(HashMap.empty<string, unknown>());\n\n  const storage: MimicDataStorage = {\n    load: (documentId: string) =>\n      Effect.gen(function* () {\n        const current = yield* Ref.get(store);\n        const result = HashMap.get(current, documentId);\n        return result._tag === \"Some\" ? result.value : undefined;\n      }),\n\n    save: (documentId: string, state: unknown) =>\n      Ref.update(store, (map) => HashMap.set(map, documentId, state)),\n\n    delete: (documentId: string) =>\n      Ref.update(store, (map) => HashMap.remove(map, documentId)),\n\n    onLoad: (state: unknown) => Effect.succeed(state),\n\n    onSave: (state: unknown) => Effect.succeed(state),\n  };\n\n  return storage;\n});\n\n// =============================================================================\n// Layer\n// =============================================================================\n\n/**\n * Layer that provides in-memory data storage.\n * This is the default storage implementation - ephemeral and non-persistent.\n */\nexport const layer: Layer.Layer<MimicDataStorageTag> = Layer.effect(\n  MimicDataStorageTag,\n  makeInMemoryStorage\n);\n\n/**\n * Default layer alias for convenience.\n */\nexport const layerDefault = layer;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,sBAAsB,OAAO,IAAI,aAAa;CAElD,MAAM,QAAQ,OAAO,IAAI,KAAK,QAAQ,OAAwB,CAAC;AAqB/D,QAnBkC;EAChC,OAAO,eACL,OAAO,IAAI,aAAa;GACtB,MAAM,UAAU,OAAO,IAAI,IAAI,MAAM;GACrC,MAAM,SAAS,QAAQ,IAAI,SAAS,WAAW;AAC/C,UAAO,OAAO,SAAS,SAAS,OAAO,QAAQ;IAC/C;EAEJ,OAAO,YAAoB,UACzB,IAAI,OAAO,QAAQ,QAAQ,QAAQ,IAAI,KAAK,YAAY,MAAM,CAAC;EAEjE,SAAS,eACP,IAAI,OAAO,QAAQ,QAAQ,QAAQ,OAAO,KAAK,WAAW,CAAC;EAE7D,SAAS,UAAmB,OAAO,QAAQ,MAAM;EAEjD,SAAS,UAAmB,OAAO,QAAQ,MAAM;EAClD;EAGD;;;;;AAUF,MAAaA,QAA0C,MAAM,OAC3D,qBACA,oBACD;;;;AAKD,MAAa,eAAe"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidhash/mimic-effect",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "repository": {
     "type": "git",
@@ -24,11 +24,11 @@
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@voidhash/tsconfig": "0.0.2"
+    "@voidhash/tsconfig": "0.0.4"
   },
   "peerDependencies": {
     "effect": "^3.19.12",
-    "@voidhash/mimic": "0.0.2"
+    "@voidhash/mimic": "0.0.4"
   },
   "scripts": {
     "build": "tsdown",

package/src/DocumentManager.ts

@@ -113,10 +113,10 @@ const makeDocumentManager = Effect.gen(function* () {
         () => Effect.succeed(undefined)
       );
 
-      // Transform loaded state with onLoad hook
+      // Transform loaded state with onLoad hook, or use configured initial state for new docs
       const initialState = rawState !== undefined
         ? yield* storage.onLoad(rawState)
-        : undefined;
+        : config.initial;
 
       // Create PubSub for broadcasting
       const pubsub = yield* PubSub.unbounded<Protocol.ServerBroadcast>();

package/src/MimicConfig.ts

@@ -6,7 +6,7 @@ import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import type { DurationInput } from "effect/Duration";
 import * as Layer from "effect/Layer";
-import type { Primitive, Presence } from "@voidhash/mimic";
+import { Primitive, Presence } from "@voidhash/mimic";
 
 // =============================================================================
 // Mimic Server Configuration
@@ -54,6 +54,13 @@ export interface MimicServerConfig<TSchema extends Primitive.AnyPrimitive = Prim
    * @default undefined (presence disabled)
    */
   readonly presence: Presence.AnyPresence | undefined;
+
+  /**
+   * Initial state for new documents.
+   * Used when a document is created and no existing state is found in storage.
+   * @default undefined (documents start empty)
+   */
+  readonly initial: Primitive.InferState<TSchema> | undefined;
 }
 
 /**
@@ -95,6 +102,17 @@ export interface MimicServerConfigOptions<TSchema extends Primitive.AnyPrimitive
    * @default undefined (presence disabled)
    */
   readonly presence?: Presence.AnyPresence;
+
+  /**
+   * Initial state for new documents.
+   * Used when a document is created and no existing state is found in storage.
+   *
+   * Type-safe: required fields (without defaults) must be provided,
+   * while optional fields and fields with defaults can be omitted.
+   *
+   * @default undefined (documents start empty or use schema defaults)
+   */
+  readonly initial?: Primitive.InferSetInput<TSchema>;
 }
 
 /**
@@ -109,6 +127,9 @@ export const make = <TSchema extends Primitive.AnyPrimitive>(
   heartbeatInterval: Duration.decode(options.heartbeatInterval ?? "30 seconds"),
   heartbeatTimeout: Duration.decode(options.heartbeatTimeout ?? "10 seconds"),
   presence: options.presence,
+  initial: options.initial !== undefined
+    ? Primitive.applyDefaults(options.schema, options.initial as Partial<Primitive.InferState<TSchema>>)
+    : undefined,
 });
 
 // =============================================================================

package/src/MimicServer.ts

@@ -20,20 +20,6 @@ import * as NoAuth from "./auth/NoAuth.js";
 import { HttpLayerRouter, HttpServerRequest, HttpServerResponse } from "@effect/platform";
 import { PathInput } from "@effect/platform/HttpRouter";
 
-// =============================================================================
-// Handler Tag
-// =============================================================================
-
-/**
- * Tag for the WebSocket handler function.
- */
-export class MimicWebSocketHandler extends Context.Tag(
-  "@voidhash/mimic-server-effect/MimicWebSocketHandler"
-)<
-  MimicWebSocketHandler,
-  (socket: Socket.Socket, documentId: string) => Effect.Effect<void, unknown>
->() {}
-
 // =============================================================================
 // Layer Composition Options
 // =============================================================================
@@ -61,121 +47,18 @@ export interface MimicLayerOptions<TSchema extends Primitive.AnyPrimitive> {
    * When provided, enables presence features on WebSocket connections.
    */
   readonly presence?: Presence.AnyPresence;
+  /**
+   * Initial state for new documents.
+   * Used when a document is created and no existing state is found in storage.
+   *
+   * Type-safe: required fields (without defaults) must be provided,
+   * while optional fields and fields with defaults can be omitted.
+   *
+   * @default undefined (documents start empty or use schema defaults)
+   */
+  readonly initial?: Primitive.InferSetInput<TSchema>;
 }
 
-// =============================================================================
-// Layer Composition
-// =============================================================================
-
-/**
- * Create a Mimic WebSocket handler layer.
- * 
- * This layer provides a handler function that can be used with any WebSocket server
- * implementation. The handler takes a socket and document ID and manages the
- * document synchronization.
- * 
- * By default, uses in-memory storage and no authentication.
- * Override these by providing MimicDataStorage and MimicAuthService layers.
- * 
- * @example
- * ```typescript
- * import { MimicServer, MimicAuthService } from "@voidhash/mimic-effect";
- * import { Primitive } from "@voidhash/mimic";
- * 
- * const TodoSchema = Primitive.Struct({
- *   title: Primitive.String(),
- *   completed: Primitive.Boolean(),
- * });
- * 
- * // Create the handler layer with defaults
- * const HandlerLayer = MimicServer.layer({
- *   basePath: "/mimic/todo",
- *   schema: TodoSchema
- * });
- * 
- * // Or with custom auth
- * const HandlerLayerWithAuth = MimicServer.layer({
- *   basePath: "/mimic/todo",
- *   schema: TodoSchema
- * }).pipe(
- *   Layer.provideMerge(MimicAuthService.layer({
- *     authHandler: (token) => ({ success: true, userId: "user-123" })
- *   }))
- * );
- * ```
- */
-export const layer = <TSchema extends Primitive.AnyPrimitive>(
-  options: MimicLayerOptions<TSchema>
-): Layer.Layer<MimicWebSocketHandler | DocumentManager.DocumentManagerTag> => {
-  const configLayer = MimicConfig.layer({
-    schema: options.schema,
-    maxTransactionHistory: options.maxTransactionHistory,
-    presence: options.presence,
-  });
-
-  return Layer.merge(
-    // Handler layer
-    Layer.effect(MimicWebSocketHandler, WebSocketHandler.makeHandler).pipe(
-      Layer.provide(DocumentManager.layer),
-      Layer.provide(PresenceManager.layer),
-      Layer.provide(configLayer)
-    ),
-    // Document manager layer
-    DocumentManager.layer.pipe(Layer.provide(configLayer))
-  ).pipe(
-    // Provide defaults if not overridden
-    Layer.provide(InMemoryDataStorage.layerDefault),
-    Layer.provide(NoAuth.layerDefault)
-  );
-};
-
-/**
- * Create the Mimic server handler layer.
- * This layer provides the WebSocket handler that can be used with any WebSocket server.
- *
- * @example
- * ```typescript
- * import { MimicServer } from "@voidhash/mimic-server-effect";
- * import { SocketServer } from "@effect/platform/SocketServer";
- * import { Primitive } from "@voidhash/mimic";
- *
- * // Define your document schema
- * const TodoSchema = Primitive.Struct({
- *   title: Primitive.String(),
- *   completed: Primitive.Boolean(),
- * });
- *
- * // Create the server layer
- * const serverLayer = MimicServer.handlerLayer({
- *   schema: TodoSchema,
- * });
- *
- * // Run with your socket server
- * Effect.gen(function* () {
- *   const handler = yield* MimicServer.MimicWebSocketHandler;
- *   const server = yield* SocketServer;
- *
- *   yield* server.run((socket) =>
- *     // Extract document ID from request and call handler
- *     handler(socket, "my-document-id")
- *   );
- * }).pipe(
- *   Effect.provide(serverLayer),
- *   Effect.provide(YourSocketServerLayer),
- * );
- * ```
- */
-export const handlerLayer = <TSchema extends Primitive.AnyPrimitive>(
-  options: MimicConfig.MimicServerConfigOptions<TSchema>
-): Layer.Layer<MimicWebSocketHandler> =>
-  Layer.effect(MimicWebSocketHandler, WebSocketHandler.makeHandler).pipe(
-    Layer.provide(DocumentManager.layer),
-    Layer.provide(PresenceManager.layer),
-    Layer.provide(MimicConfig.layer(options)),
-    // Provide defaults
-    Layer.provide(InMemoryDataStorage.layerDefault),
-    Layer.provide(NoAuth.layerDefault)
-  );
 
 /**
  * Create the document manager layer.
@@ -190,40 +73,6 @@ export const documentManagerLayer = <TSchema extends Primitive.AnyPrimitive>(
     Layer.provide(NoAuth.layerDefault)
   );
 
-// =============================================================================
-// Convenience Functions
-// =============================================================================
-
-/**
- * Run a Mimic WebSocket server with the provided handler.
- *
- * This is a helper that:
- * 1. Gets the WebSocket handler from context
- * 2. Runs the socket server with the handler
- *
- * Note: The document ID extraction from socket is implementation-specific.
- * You may need to customize this based on your socket server.
- */
-export const run = (
-  extractDocumentId: (socket: Socket.Socket) => Effect.Effect<string>
-) =>
-  Effect.gen(function* () {
-    const handler = yield* MimicWebSocketHandler;
-    const server = yield* SocketServer;
-
-    yield* server.run((socket) =>
-      Effect.gen(function* () {
-        const documentId = yield* extractDocumentId(socket);
-        yield* handler(socket, documentId);
-      }).pipe(
-        Effect.catchAll((error) =>
-          Effect.logError("Connection error", error)
-        )
-      )
-    );
-  });
-
-
 /**
  * Create the HTTP handler effect for WebSocket upgrade.
  * This handler:
@@ -339,6 +188,7 @@ export const layerHttpLayerRouter = <TSchema extends Primitive.AnyPrimitive>(
     schema: options.schema,
     maxTransactionHistory: options.maxTransactionHistory,
     presence: options.presence,
+    initial: options.initial,
   });
 
   // Use provided layers or defaults

package/tests/DocumentManager.test.ts

@@ -337,4 +337,65 @@ describe("DocumentManager", () => {
       expect(result).toBe(true);
     });
   });
+
+  describe("initial state", () => {
+    const makeTestLayerWithInitial = (initial: { title?: string; count?: number }) => {
+      const configLayer = MimicConfig.layer({
+        schema: TestSchema,
+        maxTransactionHistory: 100,
+        initial,
+      });
+
+      return DocumentManager.layer.pipe(
+        Layer.provide(configLayer),
+        Layer.provide(InMemoryDataStorage.layer)
+      );
+    };
+
+    it("should use initial state for new documents", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          return yield* manager.getSnapshot("new-doc");
+        }).pipe(Effect.provide(makeTestLayerWithInitial({ title: "Initial Title", count: 42 })))
+      );
+
+      expect(result.type).toBe("snapshot");
+      expect(result.version).toBe(0);
+      expect(result.state).toEqual({ title: "Initial Title", count: 42 });
+    });
+
+    it("should apply defaults for omitted fields in initial state", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          return yield* manager.getSnapshot("new-doc");
+        }).pipe(Effect.provide(makeTestLayerWithInitial({ title: "Only Title" })))
+      );
+
+      expect(result.type).toBe("snapshot");
+      // count should be 0 (default)
+      expect(result.state).toEqual({ title: "Only Title", count: 0 });
+    });
+
+    it("should prefer stored state over initial state", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+
+          // Apply a transaction to modify the document
+          const tx = createValidTransaction("tx-1", "Modified Title");
+          yield* manager.submit("doc-1", tx);
+
+          // Get snapshot - should show modified state, not initial
+          return yield* manager.getSnapshot("doc-1");
+        }).pipe(Effect.provide(makeTestLayerWithInitial({ title: "Initial Title", count: 42 })))
+      );
+
+      expect(result.type).toBe("snapshot");
+      expect((result.state as any).title).toBe("Modified Title");
+      // count should still be 42 since we only modified title
+      expect((result.state as any).count).toBe(42);
+    });
+  });
 });

package/tests/MimicConfig.test.ts

@@ -172,4 +172,76 @@ describe("MimicConfig", () => {
       expect(config.presence).toBe(CursorPresence);
     });
   });
+
+  describe("initial state configuration", () => {
+    it("should have undefined initial state by default", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+      });
+
+      expect(config.initial).toBeUndefined();
+    });
+
+    it("should accept initial state option", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        initial: { title: "My Document", count: 42 },
+      });
+
+      expect(config.initial).toEqual({ title: "My Document", count: 42 });
+    });
+
+    it("should apply defaults for omitted fields in initial state", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        initial: { title: "My Document" }, // count has default of 0
+      });
+
+      expect(config.initial).toEqual({ title: "My Document", count: 0 });
+    });
+
+    it("should provide initial state through layer", async () => {
+      const testLayer = MimicConfig.layer({
+        schema: TestSchema,
+        initial: { title: "From Layer", count: 100 },
+      });
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const config = yield* MimicConfig.MimicServerConfigTag;
+          return config.initial;
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toEqual({ title: "From Layer", count: 100 });
+    });
+
+    it("should work with schema that has required fields without defaults", () => {
+      const SchemaWithRequired = Primitive.Struct({
+        name: Primitive.String().required(),
+        optional: Primitive.String().default("default"),
+      });
+
+      const config = MimicConfig.make({
+        schema: SchemaWithRequired,
+        initial: { name: "Required Name" },
+      });
+
+      expect(config.initial).toEqual({ name: "Required Name", optional: "default" });
+    });
+
+    it("should work with all options including initial", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        maxIdleTime: "10 minutes",
+        maxTransactionHistory: 500,
+        initial: { title: "Full Options", count: 999 },
+      });
+
+      expect(config.schema).toBe(TestSchema);
+      expect(Duration.toMillis(config.maxIdleTime)).toBe(10 * 60 * 1000);
+      expect(config.maxTransactionHistory).toBe(500);
+      expect(config.initial).toEqual({ title: "Full Options", count: 999 });
+    });
+  });
 });