@dxos/functions 0.8.4-main.67995b8 → 0.8.4-main.a4bbb77

package/src/services/local-function-execution.ts

@@ -4,45 +4,99 @@
 
 import { Context, Effect, Layer, Schema } from 'effect';
 
+import { AiService } from '@dxos/ai';
 import { todo } from '@dxos/debug';
+import { log } from '@dxos/log';
 
+import { FunctionError, FunctionNotFoundError } from '../errors';
 import type { FunctionContext, FunctionDefinition } from '../handler';
+
+import { CredentialsService } from './credentials';
+import { DatabaseService } from './database';
+import { type ComputeEventLogger } from './event-logger';
+import { QueueService } from './queues';
+import { RemoteFunctionExecutionService } from './remote-function-execution-service';
 import type { Services } from './service-container';
-import { FunctionError } from '../errors';
+import { type TracingService } from './tracing';
+
+/**
+ * Services that are provided at the function call site.
+ */
+export type InvocationServices = TracingService | ComputeEventLogger;
 
 export class LocalFunctionExecutionService extends Context.Tag('@dxos/functions/LocalFunctionExecutionService')<
   LocalFunctionExecutionService,
   {
     // TODO(dmaretskyi): This should take function id instead of the definition object.
     // TODO(dmaretskyi): Services should be satisfied from environment rather then bubbled up.
-    invokeFunction(fnDef: FunctionDefinition<any, any>, input: unknown): Effect.Effect<unknown, never, Services>;
+    invokeFunction<I, O>(functionDef: FunctionDefinition<I, O>, input: I): Effect.Effect<O, never, InvocationServices>;
   }
 >() {
-  static layer = Layer.succeed(LocalFunctionExecutionService, {
-    invokeFunction: (fnDef, input) => invokeFunction(fnDef, input),
-  });
+  static layerLive = Layer.effect(
+    LocalFunctionExecutionService,
+    Effect.gen(function* () {
+      // TODO(dmaretskyi): Use `yield* Effect.context()`;
+      const resolver = yield* FunctionImplementationResolver;
+      const ai = yield* AiService.AiService;
+      const credentials = yield* CredentialsService;
+      const database = yield* DatabaseService;
+      const queues = yield* QueueService;
+      // TODO(mykola): Delete, should not be required for local execution.
+      const functionCallService = yield* RemoteFunctionExecutionService;
+      return {
+        // TODO(dmaretskyi): Better error types.
+        invokeFunction: <I, O>(
+          functionDef: FunctionDefinition<I, O>,
+          input: I,
+        ): Effect.Effect<O, never, InvocationServices> =>
+          Effect.gen(function* () {
+            const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect.orDie);
+            const output = yield* invokeFunction(resolved, input);
+            return output as O;
+          }).pipe(
+            Effect.provideService(AiService.AiService, ai),
+            Effect.provideService(CredentialsService, credentials),
+            Effect.provideService(DatabaseService, database),
+            Effect.provideService(QueueService, queues),
+            Effect.provideService(RemoteFunctionExecutionService, functionCallService),
+          ),
+      };
+    }),
+  );
+
+  static invokeFunction: <F extends FunctionDefinition.Any>(
+    functionDef: F,
+    input: FunctionDefinition.Input<F>,
+  ) => Effect.Effect<FunctionDefinition.Output<F>, never, Services | LocalFunctionExecutionService> =
+    Effect.serviceFunctionEffect(LocalFunctionExecutionService, (_) => _.invokeFunction as any);
 }
 
-const invokeFunction = (fnDef: FunctionDefinition<any, any>, input: any): Effect.Effect<unknown, never, Services> =>
+const invokeFunction = (
+  functionDef: FunctionDefinition<any, any>,
+  input: any,
+): Effect.Effect<unknown, never, Services> =>
   Effect.gen(function* () {
     // Assert input matches schema
-    const assertInput = fnDef.inputSchema.pipe(Schema.asserts);
-    (assertInput as any)(input);
+    try {
+      const assertInput = functionDef.inputSchema.pipe(Schema.asserts);
+      (assertInput as any)(input);
+    } catch (e) {
+      throw new FunctionError({ message: 'Invalid function input', context: { name: functionDef.name }, cause: e });
+    }
 
     const context: FunctionContext = {
+      space: undefined,
       getService: () => todo(),
       getSpace: async (_spaceId: any) => {
         throw new Error('Not available. Use the database service instead.');
       },
-      space: undefined,
-      get ai(): never {
-        throw new Error('Not available. Use the ai service instead.');
-      },
     };
 
+    log.info('Invoking function', { name: functionDef.name, input });
+
     // TODO(dmaretskyi): This should be delegated to a function invoker service.
     const data = yield* Effect.gen(function* () {
-      const result = fnDef.handler({ context, data: input });
+      const result = functionDef.handler({ context, data: input });
       if (Effect.isEffect(result)) {
         return yield* (result as Effect.Effect<unknown, unknown, Services>).pipe(Effect.orDie);
       } else if (
@@ -58,13 +112,39 @@ const invokeFunction = (fnDef: FunctionDefinition<any, any>, input: any): Effect
     }).pipe(
       Effect.orDie,
       Effect.catchAllDefect((defect) =>
-        Effect.die(new FunctionError('Error running function', { context: { name: fnDef.name }, cause: defect })),
+        Effect.die(new FunctionError({ context: { name: functionDef.name }, cause: defect })),
       ),
     );
 
+    log.info('Function completed', { name: functionDef.name, input, data });
+
     // Assert output matches schema
-    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(data);
+    try {
+      const assertOutput = functionDef.outputSchema?.pipe(Schema.asserts);
+      (assertOutput as any)(data);
+    } catch (e) {
+      throw new FunctionError({ message: 'Invalid function output', context: { name: functionDef.name }, cause: e });
+    }
 
     return data;
-  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: fnDef.name } }));
+  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: functionDef.name } }));
+
+export class FunctionImplementationResolver extends Context.Tag('@dxos/functions/FunctionImplementationResolver')<
+  FunctionImplementationResolver,
+  {
+    resolveFunctionImplementation<I, O>(
+      functionDef: FunctionDefinition<I, O>,
+    ): Effect.Effect<FunctionDefinition<I, O>, FunctionNotFoundError>;
+  }
+>() {
+  static layerTest = ({ functions }: { functions: FunctionDefinition<any, any>[] }) =>
+    Layer.succeed(FunctionImplementationResolver, {
+      resolveFunctionImplementation: <I, O>(functionDef: FunctionDefinition<I, O>) => {
+        const resolved = functions.find((f) => f.key === functionDef.key);
+        if (!resolved) {
+          return Effect.fail(new FunctionNotFoundError(functionDef.name));
+        }
+        return Effect.succeed(resolved);
+      },
+    });
+}

package/src/services/queues.ts

@@ -2,9 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Layer } from 'effect';
+import { Context, Effect, Layer } from 'effect';
 
+import type { Obj, Relation } from '@dxos/echo';
 import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
+import type { DXN, QueueSubspaceTag } from '@dxos/keys';
 
 /**
  * Gives access to all queues.
@@ -21,30 +23,50 @@ export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
      * The queue that is used to store the context of the current research.
      * @deprecated Use `ContextQueueService` instead.
      */
-    readonly contextQueue: Queue | undefined;
+    readonly queue: Queue | undefined;
   }
 >() {
   static notAvailable = Layer.succeed(QueueService, {
     queues: {
-      get(dxn) {
+      get(_dxn) {
         throw new Error('Queues not available');
       },
       create() {
         throw new Error('Queues not available');
       },
     },
-    contextQueue: undefined,
+    queue: undefined,
   });
 
-  static make = (queues: QueueFactory, contextQueue?: Queue): Context.Tag.Service<QueueService> => {
+  static make = (queues: QueueFactory, queue?: Queue): Context.Tag.Service<QueueService> => {
     return {
       queues,
-      contextQueue,
+      queue,
     };
   };
 
-  static makeLayer = (queues: QueueFactory, contextQueue?: Queue): Layer.Layer<QueueService> =>
-    Layer.succeed(QueueService, QueueService.make(queues, contextQueue));
+  static layer = (queues: QueueFactory, queue?: Queue): Layer.Layer<QueueService> =>
+    Layer.succeed(QueueService, QueueService.make(queues, queue));
+
+  /**
+   * Gets a queue by its DXN.
+   */
+  static getQueue = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
+    dxn: DXN,
+  ): Effect.Effect<Queue<T>, never, QueueService> => QueueService.pipe(Effect.map(({ queues }) => queues.get<T>(dxn)));
+
+  /**
+   * Creates a new queue.
+   */
+  static createQueue = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(options?: {
+    subspaceTag?: QueueSubspaceTag;
+  }): Effect.Effect<Queue<T>, never, QueueService> =>
+    QueueService.pipe(Effect.map(({ queues }) => queues.create<T>(options)));
+
+  static append = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
+    queue: Queue<T>,
+    objects: T[],
+  ): Effect.Effect<void> => Effect.promise(() => queue.append(objects));
 }
 
 /**
@@ -53,6 +75,8 @@ export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
 export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQueueService')<
   ContextQueueService,
   {
-    readonly contextQueue: Queue;
+    readonly queue: Queue;
   }
->() {}
+>() {
+  static layer = (queue: Queue) => Layer.succeed(ContextQueueService, { queue });
+}

package/src/services/remote-function-execution-service.ts

@@ -2,65 +2,60 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Layer } from 'effect';
+import { Context, Effect, Layer } from 'effect';
 
 import type { SpaceId } from '@dxos/keys';
 
+import { FunctionError } from '../errors';
+import { getInvocationUrl } from '../url';
+
 /**
  * Allows calling into other functions.
  */
 export class RemoteFunctionExecutionService extends Context.Tag('@dxos/functions/RemoteFunctionExecutionService')<
   RemoteFunctionExecutionService,
   {
-    callFunction(deployedFunctionId: string, input: any, spaceId?: SpaceId): Promise<any>;
+    callFunction<I, O>(deployedFunctionId: string, input: I): Effect.Effect<O>;
   }
 >() {
-  static fromClient(baseUrl: string, spaceId: SpaceId): Context.Tag.Service<RemoteFunctionExecutionService> {
-    return {
-      callFunction: async (deployedFunctionId: string, input: any) => {
-        const url = getInvocationUrl(deployedFunctionId, baseUrl, { spaceId });
-        const result = await fetch(url, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(input),
-        });
-        if (result.status >= 300 || result.status < 200) {
-          throw new Error('Failed to invoke function', { cause: new Error(`HTTP error: ${await result.text()}`) });
-        }
-        return await result.json();
-      },
-    };
+  /**
+   * @param baseUrl URL of the EDGE server.
+   * @param spaceId - The space ID to invoke the function in. If not provided, the function will be without space context.
+   * @returns
+   */
+  static fromClient(baseUrl: string, spaceId?: SpaceId): Layer.Layer<RemoteFunctionExecutionService> {
+    return Layer.succeed(RemoteFunctionExecutionService, {
+      callFunction: <I, O>(deployedFunctionId: string, input: I): Effect.Effect<O> =>
+        Effect.gen(function* () {
+          const url = getInvocationUrl(deployedFunctionId, baseUrl, { spaceId });
+          const result = yield* Effect.promise(() =>
+            fetch(url, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify(input),
+            }),
+          );
+          if (result.status >= 300 || result.status < 200) {
+            const text = yield* Effect.promise(() => result.text());
+            return yield* Effect.die(
+              new FunctionError({
+                message: 'Failed to invoke function',
+                cause: new Error(`HTTP error: ${text}`),
+              }),
+            );
+          }
+          const data = (yield* Effect.promise(() => result.json())) as O;
+          return data;
+        }),
+    });
   }
 
   static mock = (): Context.Tag.Service<RemoteFunctionExecutionService> => {
     return {
-      callFunction: async (deployedFunctionId: string, input: any) => {
-        return input;
-      },
+      callFunction: <I, O>(deployedFunctionId: string, input: I): Effect.Effect<O> =>
+        Effect.succeed(input as unknown as O),
     };
   };
 
-  static mockLayer = Layer.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock());
+  static layerMock = Layer.succeed(RemoteFunctionExecutionService, RemoteFunctionExecutionService.mock());
 }
-
-// TODO(dmaretskyi): Reconcile with `getInvocationUrl` in `@dxos/functions/edge`.
-const getInvocationUrl = (functionUrl: string, edgeUrl: string, options: InvocationOptions = {}) => {
-  const baseUrl = new URL('functions/', edgeUrl);
-
-  // Leading slashes cause the URL to be treated as an absolute path.
-  const relativeUrl = functionUrl.replace(/^\//, '');
-  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
-  options.spaceId && url.searchParams.set('spaceId', options.spaceId);
-  options.subjectId && url.searchParams.set('subjectId', options.subjectId);
-  url.protocol = isSecure(url.protocol) ? 'https' : 'http';
-  return url.toString();
-};
-
-const isSecure = (protocol: string) => {
-  return protocol === 'https:' || protocol === 'wss:';
-};
-
-type InvocationOptions = {
-  spaceId?: SpaceId;
-  subjectId?: string;
-};

package/src/services/service-container.ts

@@ -20,7 +20,7 @@ import { TracingService } from './tracing';
  * List of all services.
  */
 const SERVICES = {
-  ai: AiService,
+  ai: AiService.AiService,
   credentials: CredentialsService,
   database: DatabaseService,
   eventLogger: ComputeEventLogger,
@@ -88,9 +88,10 @@ export class ServiceContainer {
     return new ServiceContainer().setServices({ ...this._services });
   }
 
-  // TODO(dmaretskyi): `getService` is designed to error at runtime if the service is not available, but layer forces us to provide all services and makes stubs for the ones that are not available.
+  // TODO(dmaretskyi): `getService` is designed to error at runtime if the service is not available, but Layer forces us to provide all services and makes stubs for the ones that are not available.
   createLayer(): Layer.Layer<Services> {
-    const ai = this._services.ai != null ? Layer.succeed(AiService, this._services.ai) : AiService.notAvailable;
+    const ai =
+      this._services.ai != null ? Layer.succeed(AiService.AiService, this._services.ai) : AiService.notAvailable;
     const credentials = Layer.succeed(
       CredentialsService,
       this._services.credentials ?? new ConfiguredCredentialsService(),

package/src/services/service-registry.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, flow, type Option } from 'effect';
+import { Context, Effect, type Option, flow } from 'effect';
 
 import { ServiceNotAvailableError } from '../errors';
 

package/src/services/tracing.ts

@@ -6,7 +6,10 @@ import { Context, Effect, Layer } from 'effect';
 
 import { AgentStatus } from '@dxos/ai';
 import { Obj } from '@dxos/echo';
-import type { AnyEchoObject } from '@dxos/echo-schema';
+import type { Queue } from '@dxos/echo-db';
+import type { ObjectId } from '@dxos/echo-schema';
+import { log } from '@dxos/log';
+import { DataType } from '@dxos/schema';
 
 /**
  * Provides a way for compute primitives (functions, workflows, tools)
@@ -15,30 +18,124 @@ import type { AnyEchoObject } from '@dxos/echo-schema';
 export class TracingService extends Context.Tag('@dxos/functions/TracingService')<
   TracingService,
   {
+    /**
+     * Gets the parent message ID.
+     */
+    getTraceContext: () => TracingService.TraceContext;
+
     /**
      * Write an event to the tracing queue.
      * @param event - The event to write. Must be an a typed object.
      */
-    write(event: AnyEchoObject): void;
+    write: (event: Obj.Any) => void;
   }
 >() {
-  static noop: Context.Tag.Service<TracingService> = { write: () => {} };
+  static noop: Context.Tag.Service<TracingService> = { write: () => {}, getTraceContext: () => ({}) };
 
   static layerNoop = Layer.succeed(TracingService, TracingService.noop);
 
   static console: Context.Tag.Service<TracingService> = {
     write: (event) => {
-      // eslint-disable-next-line no-console
       console.log(event);
     },
+    getTraceContext: () => ({}),
   };
 
+  static layerConsole = Layer.succeed(TracingService, TracingService.console);
+
+  static layerLogInfo = () =>
+    Layer.succeed(TracingService, {
+      write: (event) => {
+        if (Obj.instanceOf(AgentStatus, event)) {
+          log.info('status', { message: event.message });
+        }
+      },
+      getTraceContext: () => ({}),
+    });
+
+  /**
+   * Creates a TracingService layer that emits events to the parent tracing service.
+   */
+  static layerSubframe = (mapContext: (currentContext: TracingService.TraceContext) => TracingService.TraceContext) =>
+    Layer.effect(
+      TracingService,
+      Effect.gen(function* () {
+        const tracing = yield* TracingService;
+        const context = mapContext(tracing.getTraceContext());
+        return {
+          write: (event) => tracing.write(event),
+          getTraceContext: () => context,
+        };
+      }),
+    );
+
+  static layerQueue = (queue: Queue) =>
+    Layer.effect(
+      TracingService,
+      Effect.gen(function* () {
+        // TODO(dmaretskyi): Batching.
+        return {
+          write: (event) => queue.append([event]),
+          getTraceContext: () => ({
+            debugInfo: {
+              queue: queue.dxn.toString(),
+            },
+          }),
+        };
+      }),
+    );
+
   /**
    * Emit the current human-readable execution status.
    */
-  static emitStatus: (data: Obj.MakeProps<typeof AgentStatus>) => Effect.Effect<unknown, never, void> =
-    Effect.fnUntraced(function* (data) {
-      const tracing = yield* TracingService;
-      tracing.write(Obj.make(AgentStatus, data));
-    });
+  static emitStatus: (
+    data: Omit<Obj.MakeProps<typeof AgentStatus>, 'created'>,
+  ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
+    const tracing = yield* TracingService;
+    tracing.write(
+      Obj.make(AgentStatus, {
+        parentMessage: tracing.getTraceContext().parentMessage,
+        toolCallId: tracing.getTraceContext().toolCallId,
+        created: new Date().toISOString(),
+        ...data,
+      }),
+    );
+  });
+
+  static emitConverationMessage: (
+    data: Obj.MakeProps<typeof DataType.Message>,
+  ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
+    const tracing = yield* TracingService;
+    tracing.write(
+      Obj.make(DataType.Message, {
+        parentMessage: tracing.getTraceContext().parentMessage,
+        ...data,
+        properties: {
+          [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
+          ...data.properties,
+        },
+      }),
+    );
+  });
 }
+
+export namespace TracingService {
+  export interface TraceContext {
+    /**
+     * If this thread sprung from a tool call, this is the ID of the message containing the tool call.
+     */
+    parentMessage?: ObjectId;
+
+    /**
+     * If the current thread is a byproduct of a tool call, this is the ID of the tool call.
+     */
+    toolCallId?: string;
+
+    debugInfo?: unknown;
+  }
+}
+
+/**
+ * Goes into {@link DataType.Message['properties']}
+ */
+export const MESSAGE_PROPERTY_TOOL_CALL_ID = 'toolCallId' as const;

package/src/testing/layer.ts

@@ -2,27 +2,108 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer } from 'effect';
 import type { Schema } from 'effect';
+import { Context, Effect, Layer } from 'effect';
 
+import type { EchoDatabaseImpl, QueueFactory } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
 import type { EchoHostIndexingConfig } from '@dxos/echo-pipeline';
 import { accuireReleaseResource } from '@dxos/effect';
+import { PublicKey } from '@dxos/keys';
+import type { LevelDB } from '@dxos/kv-store';
+import { createTestLevel } from '@dxos/kv-store/testing';
+import { log } from '@dxos/log';
 
 import { DatabaseService, QueueService } from '../services';
 
 const testBuilder = accuireReleaseResource(() => new EchoTestBuilder());
 
+export const testStoragePath = ({ name = PublicKey.random().toHex() }: { name?: string }) => {
+  return `/tmp/dxos-${name}`;
+};
+
 export type TestDatabaseOptions = {
   indexing?: Partial<EchoHostIndexingConfig>;
   types?: Schema.Schema.AnyNoContext[];
+  spaceKey?: PublicKey;
+  storagePath?: string;
+  onInit?: () => Effect.Effect<void, never, DatabaseService | QueueService>;
 };
 
-export const TestDatabaseLayer = ({ indexing, types }: TestDatabaseOptions = {}) =>
+export const TestDatabaseLayer = ({ indexing, types, spaceKey, storagePath, onInit }: TestDatabaseOptions = {}) =>
   Layer.scopedContext(
     Effect.gen(function* () {
       const builder = yield* testBuilder;
-      const { db, queues } = yield* Effect.promise(() => builder.createDatabase({ indexing, types }));
+
+      let kv: LevelDB | undefined;
+      if (storagePath) {
+        kv = createTestLevel(storagePath);
+        yield* Effect.promise(() => kv!.open());
+        // const keyCount = yield* Effect.promise(async () => (await kv!.iterator({ values: false }).all()).length);
+        // log.info('opened test db', { storagePath, keyCount });
+      }
+      const peer = yield* Effect.promise(() => builder.createPeer({ indexing, types, kv }));
+
+      let db: EchoDatabaseImpl | undefined;
+      let queues: QueueFactory | undefined;
+
+      if (storagePath) {
+        const testMetadata = yield* Effect.promise(async () => {
+          try {
+            return await kv!.get('test-metadata', { valueEncoding: 'json' });
+          } catch (e) {
+            if ((e as any).code === 'LEVEL_NOT_FOUND') {
+              return undefined;
+            }
+            throw e;
+          }
+        });
+        log('starting persistant test db', { storagePath, testMetadata });
+        if (!testMetadata) {
+          const key = spaceKey ?? PublicKey.random();
+          db = yield* Effect.promise(() => peer.createDatabase(key));
+          queues = peer.client.constructQueueFactory(db.spaceId);
+
+          yield* Effect.promise(() =>
+            kv!.put('test-metadata', { key: key.toHex(), rootUrl: db!.rootUrl }, { valueEncoding: 'json' }),
+          );
+
+          if (onInit) {
+            yield* onInit().pipe(
+              Effect.provideService(DatabaseService, DatabaseService.make(db)),
+              Effect.provideService(QueueService, QueueService.make(queues, undefined)),
+            );
+          }
+        } else {
+          const key = PublicKey.from((testMetadata as any).key);
+          const rootUrl = (testMetadata as any).rootUrl;
+          db = yield* Effect.promise(() => peer.openDatabase(key, rootUrl));
+          queues = peer.client.constructQueueFactory(db.spaceId);
+        }
+      } else {
+        db = yield* Effect.promise(() => peer.createDatabase(spaceKey));
+        queues = peer.client.constructQueueFactory(db.spaceId);
+        if (onInit) {
+          yield* onInit().pipe(
+            Effect.provideService(DatabaseService, DatabaseService.make(db)),
+            Effect.provideService(QueueService, QueueService.make(queues, undefined)),
+          );
+        }
+      }
+
+      yield* Effect.addFinalizer(() =>
+        Effect.promise(async () => {
+          if (kv) {
+            // {
+            //   const keyCount = (await kv.iterator({ values: false }).all()).length;
+            //   log.info('closing persistant test db', { storagePath, keyCount });
+            // }
+
+            await kv.close();
+          }
+        }),
+      );
+
       return Context.mergeAll(
         Context.make(DatabaseService, DatabaseService.make(db)),
         Context.make(QueueService, QueueService.make(queues, undefined)),

package/src/testing/logger.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, type Context } from 'effect';
+import { type Context, Effect } from 'effect';
 
 import { LogLevel } from '@dxos/log';