@voidhash/mimic-effect 0.0.9 → 1.0.0-beta.2

package/dist/MimicServer.cjs

@@ -1,125 +1,234 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const require_MimicConfig = require('./MimicConfig.cjs');
-const require_DocumentManager = require('./DocumentManager.cjs');
+const require_Errors = require('./Errors.cjs');
+const require_Metrics = require('./Metrics.cjs');
+const require_MimicServerEngine = require('./MimicServerEngine.cjs');
+const require_Protocol = require('./Protocol.cjs');
 const require_MimicAuthService = require('./MimicAuthService.cjs');
-const require_PresenceManager = require('./PresenceManager.cjs');
-const require_WebSocketHandler = require('./WebSocketHandler.cjs');
-const require_InMemoryDataStorage = require('./storage/InMemoryDataStorage.cjs');
-const require_NoAuth = require('./auth/NoAuth.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 = require("effect");
+let _voidhash_mimic = require("@voidhash/mimic");
 let _effect_platform = require("@effect/platform");
 
 //#region src/MimicServer.ts
 /**
-* @since 0.0.1
-* Mimic server layer composition.
+* @voidhash/mimic-effect - MimicServer
+*
+* WebSocket route layer for MimicServerEngine.
+* Creates routes compatible with HttpLayerRouter.
 */
-var MimicServer_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
-	documentManagerLayer: () => documentManagerLayer,
-	layerHttpLayerRouter: () => layerHttpLayerRouter
-});
+const DEFAULT_PATH = "/mimic";
+const DEFAULT_HEARTBEAT_INTERVAL = effect.Duration.seconds(30);
+const DEFAULT_HEARTBEAT_TIMEOUT = effect.Duration.seconds(10);
+/**
+* Resolve route configuration with defaults
+*/
+const resolveRouteConfig = (config) => {
+	var _config$path;
+	return {
+		path: (_config$path = config === null || config === void 0 ? void 0 : config.path) !== null && _config$path !== void 0 ? _config$path : DEFAULT_PATH,
+		heartbeatInterval: (config === null || config === void 0 ? void 0 : config.heartbeatInterval) ? effect.Duration.decode(config.heartbeatInterval) : DEFAULT_HEARTBEAT_INTERVAL,
+		heartbeatTimeout: (config === null || config === void 0 ? void 0 : config.heartbeatTimeout) ? effect.Duration.decode(config.heartbeatTimeout) : DEFAULT_HEARTBEAT_TIMEOUT
+	};
+};
 /**
-* Create the document manager layer.
+* Extract document ID from URL path.
+* Expected format: /basePath/doc/{documentId}
 */
-const documentManagerLayer = (options) => require_DocumentManager.layer.pipe(effect_Layer.provide(require_MimicConfig.layer(options)), effect_Layer.provide(require_InMemoryDataStorage.layerDefault), effect_Layer.provide(require_NoAuth.layerDefault));
+const extractDocumentId = (path) => {
+	const parts = path.replace(/^\/+/, "").split("/");
+	const docIndex = parts.lastIndexOf("doc");
+	const part = parts[docIndex + 1];
+	if (docIndex !== -1 && part) return effect.Effect.succeed(decodeURIComponent(part));
+	return effect.Effect.fail(new require_Errors.MissingDocumentIdError({ path }));
+};
 /**
-* Create the HTTP handler effect for WebSocket upgrade.
-* This handler:
-* 1. Extracts the document ID from the URL path
-* 2. Upgrades the HTTP connection to WebSocket
-* 3. Delegates to the WebSocketHandler for document sync
+* Handle a WebSocket connection for a document.
 */
-const makeMimicHandler = effect_Effect.gen(function* () {
-	const config = yield* require_MimicConfig.MimicServerConfigTag;
-	const authService = yield* require_MimicAuthService.MimicAuthServiceTag;
-	const documentManager = yield* require_DocumentManager.DocumentManagerTag;
-	const presenceManager = yield* require_PresenceManager.PresenceManagerTag;
-	return effect_Effect.gen(function* () {
-		const request = yield* _effect_platform.HttpServerRequest.HttpServerRequest;
-		yield* require_WebSocketHandler.extractDocumentId(request.url);
-		const socket = yield* request.upgrade;
-		yield* require_WebSocketHandler.handleConnection(socket, request.url).pipe(effect_Effect.provideService(require_MimicConfig.MimicServerConfigTag, config), effect_Effect.provideService(require_MimicAuthService.MimicAuthServiceTag, authService), effect_Effect.provideService(require_DocumentManager.DocumentManagerTag, documentManager), effect_Effect.provideService(require_PresenceManager.PresenceManagerTag, presenceManager), effect_Effect.scoped, effect_Effect.catchAll((error) => effect_Effect.logError("WebSocket connection error", error)));
-		return _effect_platform.HttpServerResponse.empty();
-	}).pipe(effect_Effect.catchAll((error) => effect_Effect.gen(function* () {
-		yield* effect_Effect.logWarning("WebSocket upgrade failed", error);
-		return _effect_platform.HttpServerResponse.text("WebSocket upgrade failed", { status: 400 });
-	})));
+const handleWebSocketConnection = (socket, documentId, engine, authService, _routeConfig) => effect.Effect.gen(function* () {
+	const connectionId = crypto.randomUUID();
+	const connectionStartTime = Date.now();
+	yield* effect.Metric.increment(require_Metrics.connectionsTotal);
+	yield* effect.Metric.incrementBy(require_Metrics.connectionsActive, 1);
+	const state = {
+		documentId,
+		connectionId,
+		authenticated: false,
+		hasPresence: false
+	};
+	const write = yield* socket.writer;
+	const sendMessage = (message) => write(require_Protocol.encodeServerMessage(message));
+	const sendPresenceSnapshot = effect.Effect.gen(function* () {
+		if (!engine.config.presence) return;
+		const snapshot = yield* engine.getPresenceSnapshot(documentId);
+		yield* sendMessage(require_Protocol.presenceSnapshotMessage(connectionId, snapshot.presences));
+	});
+	const sendDocumentSnapshot = effect.Effect.gen(function* () {
+		const snapshot = yield* engine.getSnapshot(documentId);
+		yield* sendMessage(require_Protocol.snapshotMessage(snapshot.state, snapshot.version));
+	});
+	const handleAuth = (token) => effect.Effect.gen(function* () {
+		const result = yield* effect.Effect.either(authService.authenticate(token, documentId));
+		if (result._tag === "Right") {
+			state.authenticated = true;
+			state.authContext = result.right;
+			yield* sendMessage(require_Protocol.authResultSuccess(result.right.userId, result.right.permission));
+			yield* sendDocumentSnapshot;
+			yield* sendPresenceSnapshot;
+		} else {
+			var _result$left$reason;
+			yield* effect.Metric.increment(require_Metrics.connectionsErrors);
+			yield* sendMessage(require_Protocol.authResultFailure((_result$left$reason = result.left.reason) !== null && _result$left$reason !== void 0 ? _result$left$reason : "Authentication failed"));
+		}
+	});
+	const handlePresenceSet = (data) => effect.Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!state.authContext) return;
+		if (!engine.config.presence) return;
+		if (state.authContext.permission !== "write") {
+			yield* effect.Effect.logWarning("Presence set rejected - read-only user", { connectionId });
+			return;
+		}
+		const validated = _voidhash_mimic.Presence.validateSafe(engine.config.presence, data);
+		if (validated === void 0) {
+			yield* effect.Effect.logWarning("Invalid presence data received", {
+				connectionId,
+				data
+			});
+			return;
+		}
+		yield* engine.setPresence(documentId, connectionId, {
+			data: validated,
+			userId: state.authContext.userId
+		});
+		state.hasPresence = true;
+	});
+	const handlePresenceClear = effect.Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!engine.config.presence) return;
+		yield* engine.removePresence(documentId, connectionId);
+		state.hasPresence = false;
+	});
+	const handleMessage = (message) => effect.Effect.gen(function* () {
+		yield* engine.touch(documentId);
+		switch (message.type) {
+			case "auth":
+				yield* handleAuth(message.token);
+				break;
+			case "ping":
+				yield* sendMessage(require_Protocol.pong());
+				break;
+			case "submit":
+				var _state$authContext;
+				if (!state.authenticated) {
+					yield* sendMessage(require_Protocol.errorMessage(message.transaction.id, "Not authenticated"));
+					return;
+				}
+				if (((_state$authContext = state.authContext) === null || _state$authContext === void 0 ? void 0 : _state$authContext.permission) !== "write") {
+					yield* sendMessage(require_Protocol.errorMessage(message.transaction.id, "Write permission required"));
+					return;
+				}
+				const submitResult = yield* engine.submit(documentId, message.transaction);
+				if (!submitResult.success) yield* sendMessage(require_Protocol.errorMessage(message.transaction.id, submitResult.reason));
+				break;
+			case "request_snapshot":
+				if (!state.authenticated) return;
+				const snapshot = yield* engine.getSnapshot(documentId);
+				yield* sendMessage(require_Protocol.snapshotMessage(snapshot.state, snapshot.version));
+				break;
+			case "presence_set":
+				yield* handlePresenceSet(message.data);
+				break;
+			case "presence_clear":
+				yield* handlePresenceClear;
+				break;
+		}
+	});
+	const subscribeFiber = yield* effect.Effect.fork(effect.Effect.gen(function* () {
+		while (!state.authenticated) yield* effect.Effect.sleep(effect.Duration.millis(100));
+		const broadcastStream = yield* engine.subscribe(documentId);
+		yield* effect.Stream.runForEach(broadcastStream, (broadcast) => sendMessage(broadcast));
+	}).pipe(effect.Effect.scoped));
+	const presenceFiber = yield* effect.Effect.fork(effect.Effect.gen(function* () {
+		if (!engine.config.presence) return;
+		while (!state.authenticated) yield* effect.Effect.sleep(effect.Duration.millis(100));
+		const presenceStream = yield* engine.subscribePresence(documentId);
+		yield* effect.Stream.runForEach(presenceStream, (event) => effect.Effect.gen(function* () {
+			if (event.id === connectionId) return;
+			if (event.type === "presence_update") yield* sendMessage(require_Protocol.presenceUpdateMessage(event.id, event.data, event.userId));
+			else if (event.type === "presence_remove") yield* sendMessage(require_Protocol.presenceRemoveMessage(event.id));
+		}));
+	}).pipe(effect.Effect.scoped));
+	yield* effect.Effect.addFinalizer(() => effect.Effect.gen(function* () {
+		const duration = Date.now() - connectionStartTime;
+		yield* effect.Fiber.interrupt(subscribeFiber);
+		yield* effect.Fiber.interrupt(presenceFiber);
+		if (state.hasPresence && engine.config.presence) yield* engine.removePresence(documentId, connectionId);
+		yield* effect.Metric.incrementBy(require_Metrics.connectionsActive, -1);
+		yield* effect.Metric.update(require_Metrics.connectionsDuration, duration);
+		yield* effect.Effect.logDebug("WebSocket connection closed", {
+			connectionId,
+			documentId,
+			durationMs: duration
+		});
+	}));
+	yield* socket.runRaw((data) => effect.Effect.gen(function* () {
+		yield* handleMessage(yield* require_Protocol.parseClientMessage(data));
+	}).pipe(effect.Effect.catchAll((error) => effect.Effect.logError("Message handling error", error))));
 });
 /**
-* Create a Mimic server layer that integrates with HttpLayerRouter.
+* Create a route layer for MimicServerEngine.
 *
-* This function creates a layer that:
-* 1. Registers a WebSocket route at the specified base path
-* 2. Handles WebSocket upgrades for document sync
-* 3. Provides all required dependencies (config, auth, storage, document manager)
-*
-* By default, uses in-memory storage and no authentication.
-* To override these defaults, provide custom layers before the defaults:
+* This creates a WebSocket route that connects to the engine.
+* Use Layer.mergeAll to compose with other routes.
 *
 * @example
 * ```typescript
-* import { MimicServer, MimicAuthService } from "@voidhash/mimic-effect";
-* import { HttpLayerRouter } from "@effect/platform";
-* import { Primitive } from "@voidhash/mimic";
-*
-* const TodoSchema = Primitive.Struct({
-*   title: Primitive.String(),
-*   completed: Primitive.Boolean(),
-* });
+* // 1. Create the engine
+* const Engine = MimicServerEngine.make({
+*   schema: DocSchema,
+*   initial: { title: "Untitled" },
+* })
 *
-* // Create the Mimic route layer with defaults
+* // 2. Create the WebSocket route
 * const MimicRoute = MimicServer.layerHttpLayerRouter({
-*   basePath: "/mimic/todo",
-*   schema: TodoSchema
-* });
+*   path: "/mimic",
+* })
+*
+* // 3. Wire together
+* const MimicLive = MimicRoute.pipe(
+*   Layer.provide(Engine),
+*   Layer.provide(ColdStorage.InMemory.make()),
+*   Layer.provide(HotStorage.InMemory.make()),
+*   Layer.provide(MimicAuthService.NoAuth.make()),
+* )
 *
-* // Or with custom auth - use Layer.provide to inject before defaults
-* const MimicRouteWithAuth = MimicServer.layerHttpLayerRouter({
-*   basePath: "/mimic/todo",
-*   schema: TodoSchema,
-*   authLayer: MimicAuthService.layer({
-*     authHandler: (token) => ({ success: true, userId: token })
-*   })
-* });
+* // 4. Compose with other routes
+* const AllRoutes = Layer.mergeAll(MimicLive, DocsRoute, OtherRoutes)
 *
-* // Merge with other routes and serve
-* const AllRoutes = Layer.mergeAll(MimicRoute, OtherRoutes);
+* // 5. Serve
 * HttpLayerRouter.serve(AllRoutes).pipe(
-*   Layer.provide(BunHttpServer.layer({ port: 3000 })),
+*   Layer.provide(NodeHttpServer.layer(createServer, { port: 3000 })),
 *   Layer.launch,
-*   BunRuntime.runMain
-* );
+*   NodeRuntime.runMain
+* )
 * ```
 */
-const layerHttpLayerRouter = (optionsEf) => {
-	return effect_Layer.unwrapScoped(effect_Effect.gen(function* () {
-		var _options$basePath, _options$authLayer, _options$storageLayer;
-		const options = yield* optionsEf;
-		const wsPath = `${(_options$basePath = options.basePath) !== null && _options$basePath !== void 0 ? _options$basePath : "/mimic"}/doc/*`;
-		const configLayer = require_MimicConfig.layer({
-			schema: options.schema,
-			maxTransactionHistory: options.maxTransactionHistory,
-			presence: options.presence,
-			initial: options.initial
+const layerHttpLayerRouter = (options) => {
+	const routeConfig = resolveRouteConfig(options);
+	const routePath = `${routeConfig.path}/doc/:documentId`;
+	return effect.Layer.scopedDiscard(effect.Effect.gen(function* () {
+		const router = yield* _effect_platform.HttpLayerRouter.HttpRouter;
+		const engine = yield* require_MimicServerEngine.MimicServerEngineTag;
+		const authService = yield* require_MimicAuthService.MimicAuthServiceTag;
+		const handler = (request) => effect.Effect.gen(function* () {
+			const documentIdResult = yield* effect.Effect.either(extractDocumentId(request.url));
+			if (documentIdResult._tag === "Left") return _effect_platform.HttpServerResponse.text(`Missing document ID in path: ${request.url}`, { status: 400 });
+			const documentId = documentIdResult.right;
+			yield* handleWebSocketConnection(yield* request.upgrade, documentId, engine, authService, routeConfig).pipe(effect.Effect.scoped, effect.Effect.catchAll((error) => effect.Effect.logError("WebSocket connection error", error)));
+			return _effect_platform.HttpServerResponse.empty();
 		});
-		const authLayer = (_options$authLayer = options.authLayer) !== null && _options$authLayer !== void 0 ? _options$authLayer : require_NoAuth.layerDefault;
-		const storageLayer = (_options$storageLayer = options.storageLayer) !== null && _options$storageLayer !== void 0 ? _options$storageLayer : require_InMemoryDataStorage.layerDefault;
-		const depsLayer = effect_Layer.mergeAll(configLayer, authLayer, storageLayer);
-		return effect_Layer.scopedDiscard(effect_Effect.gen(function* () {
-			const router = yield* _effect_platform.HttpLayerRouter.HttpRouter;
-			const handler = yield* makeMimicHandler;
-			yield* router.add("GET", wsPath, handler);
-		})).pipe(effect_Layer.provide(require_DocumentManager.layer), effect_Layer.provide(require_PresenceManager.layer), effect_Layer.provide(depsLayer));
+		yield* router.add("GET", routePath, handler);
 	}));
 };
+const MimicServer = { layerHttpLayerRouter };
 
 //#endregion
-Object.defineProperty(exports, 'MimicServer_exports', {
-  enumerable: true,
-  get: function () {
-    return MimicServer_exports;
-  }
-});
+exports.MimicServer = MimicServer;

package/dist/MimicServer.d.cts

@@ -1,116 +1,15 @@
-import { InitialFn, MimicServerConfigOptions } from "./MimicConfig.cjs";
-import { MimicDataStorageTag } from "./MimicDataStorage.cjs";
-import { DocumentManagerTag } from "./DocumentManager.cjs";
+import { MimicServerRouteConfig } from "./Types.cjs";
 import { MimicAuthServiceTag } from "./MimicAuthService.cjs";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { Presence, Primitive } from "@voidhash/mimic";
+import { MimicServerEngineTag } from "./MimicServerEngine.cjs";
+import { Layer } from "effect";
+import * as _effect_platform_HttpServerError0 from "@effect/platform/HttpServerError";
 import { HttpLayerRouter } from "@effect/platform";
-import { PathInput } from "@effect/platform/HttpRouter";
 
 //#region src/MimicServer.d.ts
-declare namespace MimicServer_d_exports {
-  export { MimicLayerOptions, MimicLayerRouterOptions, documentManagerLayer, layerHttpLayerRouter };
-}
-/**
- * Options for creating a Mimic server layer.
- */
-interface MimicLayerOptions<TSchema extends Primitive.AnyPrimitive> {
-  /**
-   * Base path for document routes (used for path matching).
-   * @example "/mimic/todo" - documents accessed at "/mimic/todo/:documentId"
-   */
-  readonly basePath?: PathInput;
-  /**
-   * The schema defining the document structure.
-   */
-  readonly schema: TSchema;
-  /**
-   * Maximum number of processed transaction IDs to track for deduplication.
-   * @default 1000
-   */
-  readonly maxTransactionHistory?: number;
-  /**
-   * Optional presence schema for ephemeral per-user data.
-   * When provided, enables presence features on WebSocket connections.
-   */
-  readonly presence?: Presence.AnyPresence;
-  /**
-   * Initial state for new documents.
-   * Can be either:
-   * - A plain object with the initial state values
-   * - A function that receives context (with documentId) and returns an Effect producing the initial state
-   *
-   * When using a function that requires Effect services (has R requirements),
-   * you must also provide `initialLayer` to supply those dependencies.
-   *
-   * 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> | InitialFn<TSchema>;
-}
-/**
- * Create the document manager layer.
- */
-declare const documentManagerLayer: <TSchema extends Primitive.AnyPrimitive>(options: MimicServerConfigOptions<TSchema>) => Layer.Layer<DocumentManagerTag>;
-/**
- * Options for layerHttpLayerRouter including optional custom layers.
- */
-interface MimicLayerRouterOptions<TSchema extends Primitive.AnyPrimitive> extends MimicLayerOptions<TSchema> {
-  /** Custom auth layer. Defaults to NoAuth (all connections allowed). */
-  readonly authLayer?: Layer.Layer<MimicAuthServiceTag>;
-  /** Custom storage layer. Defaults to InMemoryDataStorage. */
-  readonly storageLayer?: Layer.Layer<MimicDataStorageTag>;
-}
-/**
- * Create a Mimic server layer that integrates with HttpLayerRouter.
- *
- * This function creates a layer that:
- * 1. Registers a WebSocket route at the specified base path
- * 2. Handles WebSocket upgrades for document sync
- * 3. Provides all required dependencies (config, auth, storage, document manager)
- *
- * By default, uses in-memory storage and no authentication.
- * To override these defaults, provide custom layers before the defaults:
- *
- * @example
- * ```typescript
- * import { MimicServer, MimicAuthService } from "@voidhash/mimic-effect";
- * import { HttpLayerRouter } from "@effect/platform";
- * import { Primitive } from "@voidhash/mimic";
- *
- * const TodoSchema = Primitive.Struct({
- *   title: Primitive.String(),
- *   completed: Primitive.Boolean(),
- * });
- *
- * // Create the Mimic route layer with defaults
- * const MimicRoute = MimicServer.layerHttpLayerRouter({
- *   basePath: "/mimic/todo",
- *   schema: TodoSchema
- * });
- *
- * // Or with custom auth - use Layer.provide to inject before defaults
- * const MimicRouteWithAuth = MimicServer.layerHttpLayerRouter({
- *   basePath: "/mimic/todo",
- *   schema: TodoSchema,
- *   authLayer: MimicAuthService.layer({
- *     authHandler: (token) => ({ success: true, userId: token })
- *   })
- * });
- *
- * // Merge with other routes and serve
- * const AllRoutes = Layer.mergeAll(MimicRoute, OtherRoutes);
- * HttpLayerRouter.serve(AllRoutes).pipe(
- *   Layer.provide(BunHttpServer.layer({ port: 3000 })),
- *   Layer.launch,
- *   BunRuntime.runMain
- * );
- * ```
- */
-declare const layerHttpLayerRouter: <TSchema extends Primitive.AnyPrimitive, TError, TRequirements>(optionsEf: Effect.Effect<MimicLayerRouterOptions<TSchema>, TError, TRequirements>) => Layer.Layer<never, TError, TRequirements | HttpLayerRouter.HttpRouter>;
+
+declare const MimicServer: {
+  layerHttpLayerRouter: (options?: MimicServerRouteConfig) => Layer.Layer<never, never, HttpLayerRouter.HttpRouter | MimicServerEngineTag | MimicAuthServiceTag | HttpLayerRouter.Request<"Error", _effect_platform_HttpServerError0.RequestError>>;
+};
 //#endregion
-export { MimicServer_d_exports };
+export { MimicServer };
 //# sourceMappingURL=MimicServer.d.cts.map

package/dist/MimicServer.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"MimicServer.d.cts","names":[],"sources":["../src/MimicServer.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;UA6BiB,kCACC,SAAA,CAAU;;AAD5B;;;EAWmB,SAAA,QAAA,CAAA,EAJG,SAIH;EAUG;;;EAewD,SAAA,MAAA,EAzB3D,OAyB2D;EAAtB;;AAOxD;;EACgD,SAAA,qBAAA,CAAA,EAAA,MAAA;EAArC;;;;EA+DM,SAAA,QAAA,CAAA,EAtFK,QAAA,CAAS,WAsFS;EAAiB;;;;;;;;AAsDzD;;;;;;EAKa,SAAO,OAAA,CAAA,EAlIC,SAAA,CAAU,aAkIX,CAlIyB,OAkIzB,CAAA,GAlIoC,SAkIpC,CAlI0D,OAkI1D,CAAA;;;;;AACN,cA5HD,oBA4HC,EAAA,CAAA,gBA5HuC,SAAA,CAAU,YA4HjD,CAAA,CAAA,OAAA,EA3HH,wBA2HG,CA3HkC,OA2HlC,CAAA,EAAA,GA1HX,KAAA,CAAM,KA0HK,CA1HC,kBA0HD,CAAA;;;;UA5DG,wCAAwC,SAAA,CAAU,sBACzD,kBAAkB;;uBAEL,KAAA,CAAM,MAAM;;0BAET,KAAA,CAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiDzB,uCACK,SAAA,CAAU,gDAIf,MAAA,CAAO,OAAO,wBAAwB,UAAU,QAAQ,mBAClE,KAAA,CAAM,aAAa,QAAQ,gBAAgB,eAAA,CAAgB"}
+{"version":3,"file":"MimicServer.d.cts","names":[],"sources":["../src/MimicServer.ts"],"sourcesContent":[],"mappings":";;;;;;;;;cAmea;mCA7DD,2BAAsB,KAAA,CAAA,oBAAA,eAAA,CAAA,aAAA,uBAAA,sBAAA,eAAA,CAAA,iBAAA,iCAAA,CAAA,YAAA"}

package/dist/MimicServer.d.mts

@@ -1,116 +1,15 @@
-import { InitialFn, MimicServerConfigOptions } from "./MimicConfig.mjs";
-import { MimicDataStorageTag } from "./MimicDataStorage.mjs";
-import { DocumentManagerTag } from "./DocumentManager.mjs";
+import { MimicServerRouteConfig } from "./Types.mjs";
 import { MimicAuthServiceTag } from "./MimicAuthService.mjs";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { Presence, Primitive } from "@voidhash/mimic";
+import { MimicServerEngineTag } from "./MimicServerEngine.mjs";
+import { Layer } from "effect";
 import { HttpLayerRouter } from "@effect/platform";
-import { PathInput } from "@effect/platform/HttpRouter";
+import * as _effect_platform_HttpServerError0 from "@effect/platform/HttpServerError";
 
 //#region src/MimicServer.d.ts
-declare namespace MimicServer_d_exports {
-  export { MimicLayerOptions, MimicLayerRouterOptions, documentManagerLayer, layerHttpLayerRouter };
-}
-/**
- * Options for creating a Mimic server layer.
- */
-interface MimicLayerOptions<TSchema extends Primitive.AnyPrimitive> {
-  /**
-   * Base path for document routes (used for path matching).
-   * @example "/mimic/todo" - documents accessed at "/mimic/todo/:documentId"
-   */
-  readonly basePath?: PathInput;
-  /**
-   * The schema defining the document structure.
-   */
-  readonly schema: TSchema;
-  /**
-   * Maximum number of processed transaction IDs to track for deduplication.
-   * @default 1000
-   */
-  readonly maxTransactionHistory?: number;
-  /**
-   * Optional presence schema for ephemeral per-user data.
-   * When provided, enables presence features on WebSocket connections.
-   */
-  readonly presence?: Presence.AnyPresence;
-  /**
-   * Initial state for new documents.
-   * Can be either:
-   * - A plain object with the initial state values
-   * - A function that receives context (with documentId) and returns an Effect producing the initial state
-   *
-   * When using a function that requires Effect services (has R requirements),
-   * you must also provide `initialLayer` to supply those dependencies.
-   *
-   * 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> | InitialFn<TSchema>;
-}
-/**
- * Create the document manager layer.
- */
-declare const documentManagerLayer: <TSchema extends Primitive.AnyPrimitive>(options: MimicServerConfigOptions<TSchema>) => Layer.Layer<DocumentManagerTag>;
-/**
- * Options for layerHttpLayerRouter including optional custom layers.
- */
-interface MimicLayerRouterOptions<TSchema extends Primitive.AnyPrimitive> extends MimicLayerOptions<TSchema> {
-  /** Custom auth layer. Defaults to NoAuth (all connections allowed). */
-  readonly authLayer?: Layer.Layer<MimicAuthServiceTag>;
-  /** Custom storage layer. Defaults to InMemoryDataStorage. */
-  readonly storageLayer?: Layer.Layer<MimicDataStorageTag>;
-}
-/**
- * Create a Mimic server layer that integrates with HttpLayerRouter.
- *
- * This function creates a layer that:
- * 1. Registers a WebSocket route at the specified base path
- * 2. Handles WebSocket upgrades for document sync
- * 3. Provides all required dependencies (config, auth, storage, document manager)
- *
- * By default, uses in-memory storage and no authentication.
- * To override these defaults, provide custom layers before the defaults:
- *
- * @example
- * ```typescript
- * import { MimicServer, MimicAuthService } from "@voidhash/mimic-effect";
- * import { HttpLayerRouter } from "@effect/platform";
- * import { Primitive } from "@voidhash/mimic";
- *
- * const TodoSchema = Primitive.Struct({
- *   title: Primitive.String(),
- *   completed: Primitive.Boolean(),
- * });
- *
- * // Create the Mimic route layer with defaults
- * const MimicRoute = MimicServer.layerHttpLayerRouter({
- *   basePath: "/mimic/todo",
- *   schema: TodoSchema
- * });
- *
- * // Or with custom auth - use Layer.provide to inject before defaults
- * const MimicRouteWithAuth = MimicServer.layerHttpLayerRouter({
- *   basePath: "/mimic/todo",
- *   schema: TodoSchema,
- *   authLayer: MimicAuthService.layer({
- *     authHandler: (token) => ({ success: true, userId: token })
- *   })
- * });
- *
- * // Merge with other routes and serve
- * const AllRoutes = Layer.mergeAll(MimicRoute, OtherRoutes);
- * HttpLayerRouter.serve(AllRoutes).pipe(
- *   Layer.provide(BunHttpServer.layer({ port: 3000 })),
- *   Layer.launch,
- *   BunRuntime.runMain
- * );
- * ```
- */
-declare const layerHttpLayerRouter: <TSchema extends Primitive.AnyPrimitive, TError, TRequirements>(optionsEf: Effect.Effect<MimicLayerRouterOptions<TSchema>, TError, TRequirements>) => Layer.Layer<never, TError, TRequirements | HttpLayerRouter.HttpRouter>;
+
+declare const MimicServer: {
+  layerHttpLayerRouter: (options?: MimicServerRouteConfig) => Layer.Layer<never, never, HttpLayerRouter.HttpRouter | MimicServerEngineTag | MimicAuthServiceTag | HttpLayerRouter.Request<"Error", _effect_platform_HttpServerError0.RequestError>>;
+};
 //#endregion
-export { MimicServer_d_exports };
+export { MimicServer };
 //# sourceMappingURL=MimicServer.d.mts.map

package/dist/MimicServer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"MimicServer.d.mts","names":[],"sources":["../src/MimicServer.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;UA6BiB,kCACC,SAAA,CAAU;;AAD5B;;;EAWmB,SAAA,QAAA,CAAA,EAJG,SAIH;EAUG;;;EAewD,SAAA,MAAA,EAzB3D,OAyB2D;EAAtB;;AAOxD;;EACgD,SAAA,qBAAA,CAAA,EAAA,MAAA;EAArC;;;;EA+DM,SAAA,QAAA,CAAA,EAtFK,QAAA,CAAS,WAsFS;EAAiB;;;;;;;;AAsDzD;;;;;;EAKa,SAAO,OAAA,CAAA,EAlIC,SAAA,CAAU,aAkIX,CAlIyB,OAkIzB,CAAA,GAlIoC,SAkIpC,CAlI0D,OAkI1D,CAAA;;;;;AACN,cA5HD,oBA4HC,EAAA,CAAA,gBA5HuC,SAAA,CAAU,YA4HjD,CAAA,CAAA,OAAA,EA3HH,wBA2HG,CA3HkC,OA2HlC,CAAA,EAAA,GA1HX,KAAA,CAAM,KA0HK,CA1HC,kBA0HD,CAAA;;;;UA5DG,wCAAwC,SAAA,CAAU,sBACzD,kBAAkB;;uBAEL,KAAA,CAAM,MAAM;;0BAET,KAAA,CAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiDzB,uCACK,SAAA,CAAU,gDAIf,MAAA,CAAO,OAAO,wBAAwB,UAAU,QAAQ,mBAClE,KAAA,CAAM,aAAa,QAAQ,gBAAgB,eAAA,CAAgB"}
+{"version":3,"file":"MimicServer.d.mts","names":[],"sources":["../src/MimicServer.ts"],"sourcesContent":[],"mappings":";;;;;;;;;cAmea;mCA7DD,2BAAsB,KAAA,CAAA,oBAAA,eAAA,CAAA,aAAA,uBAAA,sBAAA,eAAA,CAAA,iBAAA,iCAAA,CAAA,YAAA"}