@rivetkit/effect 2.3.3-rc.1 → 2.3.3-rc.2

package/src/internal/ActorInstanceManager.ts

@@ -77,7 +77,9 @@ export const make = Effect.fnUntraced(function* <
 		const scope = yield* Scope.make();
 		return yield* Effect.gen(function* () {
 			const state = stateAdapter
-				? yield* stateAdapter.makeStateView(c)
+				? yield* stateAdapter
+						.makeStateView(c)
+						.pipe(Effect.provideService(Scope.Scope, scope))
 				: undefined;
 			const context = makeContext(c, scope);
 			const actionHandlers = yield* wakeHandler(
@@ -105,15 +107,7 @@ export const make = Effect.fnUntraced(function* <
 	return {
 		get: (actorId: string) => instances.get(actorId),
 		onWake: async (c: WakeContext<StateDefinition, Database>) => {
-			await runPromise(
-				makeInstance(c).pipe(
-					Effect.tap((instance) =>
-						Effect.sync(() => {
-							instances.set(c.actorId, instance);
-						}),
-					),
-				),
-			);
+			instances.set(c.actorId, await runPromise(makeInstance(c)));
 		},
 		onStateChange: stateAdapter
 			? (

package/src/internal/ActorStateAdapter.ts

@@ -1,10 +1,11 @@
-import { Effect, type Fiber, Schema, Semaphore } from "effect";
+import { Effect, type Fiber, Schema } from "effect";
 import * as State from "../State.ts";
 import type * as StateOptions from "./StateOptions.ts";
 
 export type ActorState<StateDefinition extends StateOptions.Any> = State.State<
 	StateOptions.Decoded<StateDefinition>,
-	Schema.SchemaError
+	Schema.SchemaError,
+	StateOptions.Services<StateDefinition>
 >;
 
 type StateInstance<StateDefinition extends StateOptions.Any> = {
@@ -71,15 +72,8 @@ export const make = Effect.fnUntraced(function* <
 					const state = yield* Effect.fromNullishOr(
 						instance.state,
 					).pipe(Effect.orDie);
-
-					yield* Semaphore.withPermit(
-						state.semaphore,
-						Effect.gen(function* () {
-							const decoded = yield* stateCodec
-								.decodeUnknown(newState)
-								.pipe(Effect.orDie);
-							State.publishUnsafe(state, decoded);
-						}),
+					yield* state[State.RuntimeTypeId].publishEffect(
+						stateCodec.decodeUnknown(newState).pipe(Effect.orDie),
 					);
 				}),
 			);

package/src/internal/StateOptions.ts

@@ -10,6 +10,10 @@ export interface Any {
 	readonly initialValue: () => unknown;
 }
 
+export type Services<State extends Any> =
+	| State["schema"]["DecodingServices"]
+	| State["schema"]["EncodingServices"];
+
 export type Encoded<State extends Any> =
 	| State["schema"]["Encoded"]
 	| ([State] extends [never] ? undefined : never);

package/src/internal/logging.test.ts

@@ -1,13 +1,6 @@
 import { assert, describe, it } from "@effect/vitest";
-import {
-	Config,
-	ConfigProvider,
-	Effect,
-	Layer,
-	Logger as EffectLogger,
-	References,
-} from "effect";
-import type { Logger as PinoLogger } from "rivetkit/log";
+import { ConfigProvider, Effect, Logger, References } from "effect";
+import * as RivetkitLog from "rivetkit/log";
 import * as Logging from "./logging.ts";
 
 type LogEntry = {
@@ -16,7 +9,7 @@ type LogEntry = {
 	readonly msg: string | undefined;
 };
 
-function makeTestLogger(entries: Array<LogEntry>): PinoLogger {
+function makeTestLogger(entries: Array<LogEntry>): RivetkitLog.Logger {
 	const logger: Record<string, unknown> = {};
 	for (const level of ["trace", "debug", "info", "warn", "error", "fatal"]) {
 		logger[level] = (
@@ -27,7 +20,7 @@ function makeTestLogger(entries: Array<LogEntry>): PinoLogger {
 		};
 	}
 
-	return logger as unknown as PinoLogger;
+	return logger as unknown as RivetkitLog.Logger;
 }
 
 describe("internal/logging", () => {
@@ -65,23 +58,21 @@ describe("internal/logging", () => {
 					key: "room-1",
 					actorId: "actor-1",
 				}),
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
+				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
 			);
 
-			assert.deepStrictEqual(entries, [
-				{
-					level: "info",
-					fields: {
-						roomId: "abc",
-						actor: "ChatRoom",
-						key: "room-1",
-						actorId: "actor-1",
-					},
-					msg: "room awake",
-				},
-			]);
+			const entry = entries[0];
+			assert.ok(entry !== undefined);
+			assert.strictEqual(entry.level, "info");
+			assert.strictEqual(entry.msg, "room awake");
+			assert.deepStrictEqual(entry.fields, {
+				roomId: "abc",
+				actor: "ChatRoom",
+				key: "room-1",
+				actorId: "actor-1",
+				fiberId: entry.fields.fiberId,
+			});
+			assert.strictEqual(typeof entry.fields.fiberId, "string");
 		}),
 	);
 
@@ -92,9 +83,7 @@ describe("internal/logging", () => {
 			const error = new Error("room failed to wake");
 
 			yield* Effect.logError(error).pipe(
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
+				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
 			);
 
 			const entry = entries[0];
@@ -115,9 +104,7 @@ describe("internal/logging", () => {
 				actorId: "actor-1",
 				action: "SendMessage",
 			}).pipe(
-				Effect.provide(
-					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
-				),
+				Effect.provide(Logger.layer([Logging.makeLogger(baseLogger)])),
 			);
 
 			const entry = entries[0];
@@ -130,17 +117,7 @@ describe("internal/logging", () => {
 		}),
 	);
 
-	it.effect(
-		"uses References.MinimumLogLevel when creating the base logger",
-		() =>
-			Effect.gen(function* () {
-				const baseLogger = yield* Logging.makeDefaultBaseLogger;
-
-				assert.strictEqual(baseLogger.level, "debug");
-			}).pipe(Effect.provideService(References.MinimumLogLevel, "Debug")),
-	);
-
-	it.effect("accepts the shared Pino RIVET_LOG_LEVEL values", () =>
+	it.effect("accepts RIVET_LOG_LEVEL values", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
@@ -157,25 +134,24 @@ describe("internal/logging", () => {
 		),
 	);
 
-	it.effect("prefers References.MinimumLogLevel over shared env values", () =>
+	it.effect("accepts uppercase RIVET_LOG_LEVEL values", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
 			assert.strictEqual(baseLogger.level, "debug");
 		}).pipe(
-			Effect.provideService(References.MinimumLogLevel, "Debug"),
 			Effect.provideService(
 				ConfigProvider.ConfigProvider,
 				ConfigProvider.fromEnv({
 					env: {
-						RIVET_LOG_LEVEL: "silent",
+						RIVET_LOG_LEVEL: "DEBUG",
 					},
 				}),
 			),
 		),
 	);
 
-	it.effect("preserves an explicit Info minimum log level", () =>
+	it.effect("ignores Effect-only RIVET_LOG_LEVEL values", () =>
 		Effect.gen(function* () {
 			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
@@ -186,36 +162,45 @@ describe("internal/logging", () => {
 				ConfigProvider.ConfigProvider,
 				ConfigProvider.fromEnv({
 					env: {
-						RIVET_LOG_LEVEL: "silent",
+						RIVET_LOG_LEVEL: "None",
 					},
 				}),
 			),
 		),
 	);
 
-	it.effect(
-		"uses Config.logLevel values provided to References.MinimumLogLevel",
-		() =>
-			Effect.gen(function* () {
-				const baseLogger = yield* Logging.makeDefaultBaseLogger;
+	it.effect("falls back to References.MinimumLogLevel without env", () =>
+		Effect.gen(function* () {
+			const baseLogger = yield* Logging.makeDefaultBaseLogger;
 
-				assert.strictEqual(baseLogger.level, "trace");
-			}).pipe(
-				Effect.provide(
-					Layer.effect(
-						References.MinimumLogLevel,
-						Config.logLevel("RIVET_LOG_LEVEL"),
-					),
-				),
-				Effect.provideService(
-					ConfigProvider.ConfigProvider,
-					ConfigProvider.fromEnv({
-						env: {
-							RIVET_LOG_LEVEL: "Trace",
-						},
-					}),
-				),
+			assert.strictEqual(baseLogger.level, "debug");
+		}).pipe(
+			Effect.provideService(References.MinimumLogLevel, "Debug"),
+			Effect.provideService(
+				ConfigProvider.ConfigProvider,
+				ConfigProvider.fromEnv({
+					env: {},
+				}),
 			),
+		),
+	);
+
+	it.effect("RIVET_LOG_LEVEL overrides References.MinimumLogLevel", () =>
+		Effect.gen(function* () {
+			const baseLogger = yield* Logging.makeDefaultBaseLogger;
+
+			assert.strictEqual(baseLogger.level, "silent");
+		}).pipe(
+			Effect.provideService(References.MinimumLogLevel, "Debug"),
+			Effect.provideService(
+				ConfigProvider.ConfigProvider,
+				ConfigProvider.fromEnv({
+					env: {
+						RIVET_LOG_LEVEL: "silent",
+					},
+				}),
+			),
+		),
 	);
 
 	it.effect(
@@ -229,19 +214,18 @@ describe("internal/logging", () => {
 					Effect.provideService(References.CurrentLogLevel, "Debug"),
 					Effect.provideService(References.MinimumLogLevel, "Debug"),
 					Effect.provide(
-						EffectLogger.layer([
-							Logging.makeEffectLogger(baseLogger),
-						]),
+						Logger.layer([Logging.makeLogger(baseLogger)]),
 					),
 				);
 
-				assert.deepStrictEqual(entries, [
-					{
-						level: "debug",
-						fields: {},
-						msg: "plain log",
-					},
-				]);
+				const entry = entries[0];
+				assert.ok(entry !== undefined);
+				assert.strictEqual(entry.level, "debug");
+				assert.strictEqual(entry.msg, "plain log");
+				assert.deepStrictEqual(entry.fields, {
+					fiberId: entry.fields.fiberId,
+				});
+				assert.strictEqual(typeof entry.fields.fiberId, "string");
 			}),
 	);
 
@@ -256,9 +240,7 @@ describe("internal/logging", () => {
 					Effect.provideService(References.CurrentLogLevel, "None"),
 					Effect.provideService(References.MinimumLogLevel, "All"),
 					Effect.provide(
-						EffectLogger.layer([
-							Logging.makeEffectLogger(baseLogger),
-						]),
+						Logger.layer([Logging.makeLogger(baseLogger)]),
 					),
 				);
 
@@ -276,18 +258,13 @@ describe("internal/logging", () => {
 				yield* Effect.logInfo("checkout complete").pipe(
 					Effect.withLogSpan("checkout"),
 					Effect.provide(
-						EffectLogger.layer([
-							Logging.makeEffectLogger(baseLogger),
-						]),
+						Logger.layer([Logging.makeLogger(baseLogger)]),
 					),
 				);
 
 				assert.strictEqual(entries.length, 1);
 				assert.strictEqual(entries[0]?.level, "info");
 				assert.strictEqual(entries[0]?.msg, "checkout complete");
-				assert.deepStrictEqual(Object.keys(entries[0]?.fields ?? {}), [
-					"spans",
-				]);
 				const spans = entries[0]?.fields.spans as
 					| Record<string, unknown>
 					| undefined;

package/src/internal/logging.ts

@@ -1,19 +1,16 @@
 import {
-	Cause,
 	Config,
 	Context,
 	Effect,
-	Logger as EffectLogger,
+	Logger,
+	Option,
+	Predicate,
+	Record as EffectRecord,
 	type LogLevel,
 	References,
 } from "effect";
 import type * as Rivetkit from "rivetkit";
-import {
-	configureDefaultLogger,
-	getBaseLogger,
-	type Logger as PinoLogger,
-	type LogLevel as PinoLogLevel,
-} from "rivetkit/log";
+import * as RivetkitLog from "rivetkit/log";
 
 const EMPTY_KEY = "/";
 const KEY_SEPARATOR = "/";
@@ -24,25 +21,14 @@ type ActorLogContext = {
 	readonly actorId: string;
 };
 
-export class BaseLogger extends Context.Service<BaseLogger, PinoLogger>()(
-	"@rivetkit/effect/Logger/BaseLogger",
-) {}
-
-const PinoLevelByEffectLevel: Record<LogLevel.LogLevel, PinoLogLevel> = {
-	All: "trace",
-	Trace: "trace",
-	Debug: "debug",
-	Info: "info",
-	Warn: "warn",
-	Error: "error",
-	Fatal: "fatal",
-	None: "silent",
-};
+export class BaseLogger extends Context.Service<
+	BaseLogger,
+	RivetkitLog.Logger
+>()("@rivetkit/effect/RivetLogger/BaseLogger") {}
 
-export const toPinoLevel = (logLevel: LogLevel.LogLevel): PinoLogLevel =>
-	PinoLevelByEffectLevel[logLevel];
+const RivetkitLogLevels = RivetkitLog.LogLevelSchema.options;
 
-const EffectLevelByPinoLevel: Record<PinoLogLevel, LogLevel.LogLevel> = {
+const EffectLevelByRivetkitLevel = {
 	trace: "Trace",
 	debug: "Debug",
 	info: "Info",
@@ -50,56 +36,54 @@ const EffectLevelByPinoLevel: Record<PinoLogLevel, LogLevel.LogLevel> = {
 	error: "Error",
 	fatal: "Fatal",
 	silent: "None",
-};
+} as const satisfies Record<
+	RivetkitLog.LogLevel,
+	Exclude<LogLevel.LogLevel, "All">
+>;
+
+const RivetkitLevelByEffectLevel = {
+	...Object.fromEntries(
+		RivetkitLogLevels.map((level) => [
+			EffectLevelByRivetkitLevel[level],
+			level,
+		]),
+	),
+	All: "trace",
+} as Record<LogLevel.LogLevel, RivetkitLog.LogLevel>;
 
-const pinoLogLevelFromEnv = Config.string("RIVET_LOG_LEVEL").pipe(
-	Config.map((value) => {
-		const pinoLevel = value.toLowerCase();
-		if (pinoLevel in EffectLevelByPinoLevel) {
-			return EffectLevelByPinoLevel[pinoLevel as PinoLogLevel];
-		}
+const rivetLogLevelFromEnv = Config.string("RIVET_LOG_LEVEL").pipe(
+	Effect.option,
+	Effect.map((maybeRivetLogLevel) => {
+		if (Option.isNone(maybeRivetLogLevel)) return Option.none();
 
-		return "Info";
+		const parsed = RivetkitLog.LogLevelSchema.safeParse(
+			maybeRivetLogLevel.value.toLowerCase(),
+		);
+		return parsed.success ? Option.some(parsed.data) : Option.none();
 	}),
 );
 
-const logLevelFromEnv = Config.logLevel("RIVET_LOG_LEVEL").pipe(
-	Config.orElse(() => pinoLogLevelFromEnv),
-	Effect.option,
-);
+export const makeDefaultBaseLogger: Effect.Effect<RivetkitLog.Logger> =
+	Effect.gen(function* () {
+		const maybeRivetLogLevel = yield* rivetLogLevelFromEnv;
+		const logLevel = Option.isSome(maybeRivetLogLevel)
+			? maybeRivetLogLevel.value
+			: RivetkitLevelByEffectLevel[yield* References.MinimumLogLevel];
 
-export const makeDefaultBaseLogger: Effect.Effect<PinoLogger> = Effect.gen(
-	function* () {
-		const context = yield* Effect.context();
-		const providedMinimumLogLevel = Context.getOrUndefined(
-			context,
-			References.MinimumLogLevel,
+		return yield* Effect.sync(() =>
+			RivetkitLog.makeDefaultLogger(logLevel),
 		);
-		const envLogLevel = yield* logLevelFromEnv;
-		const logLevel =
-			providedMinimumLogLevel !== undefined
-				? providedMinimumLogLevel
-				: envLogLevel._tag === "Some"
-					? envLogLevel.value
-					: yield* References.MinimumLogLevel;
-
-		return yield* Effect.sync(() => {
-			configureDefaultLogger(toPinoLevel(logLevel));
-			return getBaseLogger();
-		});
-	},
-);
+	});
 
-export const getOrCreateBaseLogger: Effect.Effect<PinoLogger> = Effect.gen(
-	function* () {
-		const provided = yield* Effect.serviceOption(BaseLogger);
-		if (provided._tag === "Some") {
-			return provided.value;
+export const getOrCreateBaseLogger: Effect.Effect<RivetkitLog.Logger> =
+	Effect.gen(function* () {
+		const maybeBaseLogger = yield* Effect.serviceOption(BaseLogger);
+		if (Option.isSome(maybeBaseLogger)) {
+			return maybeBaseLogger.value;
 		}
 
 		return yield* makeDefaultBaseLogger;
-	},
-);
+	});
 
 export function makeActorLogAnnotations(context: ActorLogContext): {
 	readonly actor: string;
@@ -131,59 +115,64 @@ export function serializeActorKey(key: Rivetkit.ActorKey): string {
 		.join(KEY_SEPARATOR);
 }
 
-function structuredValue(value: unknown): unknown {
-	if (value instanceof Error) {
-		return value;
-	}
+export function makeLogger(
+	baseLogger: RivetkitLog.Logger,
+): Logger.Logger<unknown, void> {
+	return Logger.make((options) => {
+		if (options.logLevel === "None") return;
+		const rivetkitLevel = RivetkitLevelByEffectLevel[options.logLevel];
+		const structured = Logger.formatStructured.log(options);
+		const { msg, fields: messageFields } = extractMessage(
+			structured.message,
+		);
+		const fields: Record<string, unknown> = {
+			...messageFields,
+			...structured.annotations,
+			fiberId: structured.fiberId,
+		};
+
+		if (!EffectRecord.isEmptyRecord(structured.spans)) {
+			fields.spans = structured.spans;
+		}
+		if (structured.cause !== undefined) {
+			fields.cause = structured.cause;
+		}
 
-	return value;
+		const logger = baseLogger[rivetkitLevel];
+		if (msg === undefined) {
+			logger.call(baseLogger, fields);
+		} else {
+			logger.call(baseLogger, fields, msg);
+		}
+	});
 }
 
-function extractMessageAndFields(message: unknown): {
+function extractMessage(message: unknown): {
 	readonly msg: string | undefined;
 	readonly fields: Record<string, unknown>;
 } {
 	const values = Array.isArray(message) ? message : [message];
-	if (values.length === 0) {
-		return { msg: undefined, fields: {} };
-	}
-
-	const [first, ...rest] = values;
 	const fields: Record<string, unknown> = {};
+	const args: Array<unknown> = [];
 	let msg: string | undefined;
 
-	if (first instanceof Error) {
-		fields.error = first;
-		msg = first.message;
-	} else if (first !== null && typeof first === "object") {
-		const firstFields = first as Record<string, unknown>;
-		for (const [key, value] of Object.entries(firstFields)) {
-			if (key === "msg") {
-				if (value !== undefined) {
-					msg = String(value);
-				}
-			} else {
-				fields[key] = structuredValue(value);
-			}
-		}
-	} else if (first !== undefined) {
-		msg = String(first);
-	}
-
-	const args: Array<unknown> = [];
-	for (const value of rest) {
-		if (value instanceof Error) {
+	for (const [index, value] of values.entries()) {
+		if (Predicate.isError(value)) {
+			fields.error = value;
+			if (index === 0) msg = value.message;
+		} else if (isStructuredError(value)) {
 			fields.error = value;
-		} else if (
-			value !== null &&
-			typeof value === "object" &&
-			!Array.isArray(value)
-		) {
-			for (const [key, fieldValue] of Object.entries(
-				value as Record<string, unknown>,
-			)) {
-				fields[key] = structuredValue(fieldValue);
+			if (index === 0) msg = value.error;
+		} else if (Predicate.isObject(value)) {
+			if (index === 0) {
+				const { msg: valueMsg, ...rest } = value;
+				Object.assign(fields, rest);
+				if (valueMsg !== undefined) msg = String(valueMsg);
+			} else {
+				Object.assign(fields, value);
 			}
+		} else if (index === 0) {
+			msg = value === undefined ? undefined : String(value);
 		} else {
 			args.push(value);
 		}
@@ -196,42 +185,13 @@ function extractMessageAndFields(message: unknown): {
 	return { msg, fields };
 }
 
-export function makeEffectLogger(
-	baseLogger: PinoLogger,
-): EffectLogger.Logger<unknown, void> {
-	return EffectLogger.make(({ cause, date, fiber, logLevel, message }) => {
-		const { msg, fields } = extractMessageAndFields(message);
-
-		for (const [key, value] of Object.entries(
-			fiber.getRef(References.CurrentLogAnnotations),
-		)) {
-			fields[key] = structuredValue(value);
-		}
-
-		const spans: Record<string, number> = {};
-		for (const [label, startTime] of fiber.getRef(
-			References.CurrentLogSpans,
-		)) {
-			spans[label] = date.getTime() - startTime;
-		}
-		if (Object.keys(spans).length > 0) {
-			fields.spans = spans;
-		}
-
-		if (cause.reasons.length > 0) {
-			fields.cause = Cause.pretty(cause);
-		}
-
-		const pinoLevel = toPinoLevel(logLevel);
-		if (pinoLevel === "silent") {
-			return;
-		}
-
-		const logger = baseLogger[pinoLevel];
-		if (msg === undefined) {
-			logger.call(baseLogger, fields);
-		} else {
-			logger.call(baseLogger, fields, msg);
-		}
-	});
+function isStructuredError(
+	value: unknown,
+): value is { readonly error: string; readonly name: string } {
+	return (
+		Predicate.hasProperty(value, "error") &&
+		Predicate.hasProperty(value, "name") &&
+		Predicate.isString(value.error) &&
+		Predicate.isString(value.name)
+	);
 }

package/src/mod.ts

@@ -1,7 +1,7 @@
 export * as Action from "./Action.ts";
 export * as Actor from "./Actor.ts";
 export * as Client from "./Client.ts";
-export * as Logger from "./Logger.ts";
 export * as Registry from "./Registry.ts";
+export * as RivetLogger from "./RivetLogger.ts";
 export * as RivetError from "./RivetError.ts";
 export * as State from "./State.ts";

package/dist/Logger.d.ts

@@ -1,29 +0,0 @@
-import { Layer } from "effect";
-import type { Logger as PinoLogger } from "rivetkit/log";
-import { BaseLogger } from "./internal/logging.ts";
-/**
- * Builds a logging layer from a custom Pino-compatible logger.
- *
- * The layer installs the matching Effect logger and configures the underlying
- * RivetKit TypeScript SDK logs to go through the same logger.
- *
- * @example
- * ```ts
- * import { Logger } from "@rivetkit/effect"
- * import { pino } from "pino"
- *
- * const LoggerLive = Logger.layerPino(
- *   pino({ transport: { target: "pino-pretty" } })
- * )
- * ```
- */
-export declare const layerPino: (baseLogger: PinoLogger) => Layer.Layer<BaseLogger, never, never>;
-/**
- * Default RivetKit Effect logging layer.
- *
- * The layer creates a base logger from `References.MinimumLogLevel` and installs
- * the Effect logger adapter. Applications that want custom formatting or
- * transports should provide {@link layerPino} instead.
- */
-export declare const layer: Layer.Layer<never>;
-//# sourceMappingURL=Logger.d.ts.map

package/dist/Logger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../src/Logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkC,KAAK,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EACN,UAAU,EAGV,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,GAAI,YAAY,UAAU,0CAO9C,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAEpC,CAAC"}