@dxos/functions 0.8.4-main.5acf9ea → 0.8.4-main.5ea62a8

package/src/services/database.ts

@@ -2,10 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer } from 'effect';
+import { Context, Effect, Layer, Option, type Schema } from 'effect';
 
-import type { Filter, Live, Obj, Query, Ref, Relation } from '@dxos/echo';
-import type { EchoDatabase, OneShotQueryResult, QueryResult } from '@dxos/echo-db';
+import { type Filter, type Live, Obj, type Query, type Ref, type Relation, type Type } from '@dxos/echo';
+import type { EchoDatabase, FlushOptions, OneShotQueryResult, QueryResult, SchemaRegistryQuery } from '@dxos/echo-db';
+import type { SchemaRegistryPreparedQuery } from '@dxos/echo-db';
+import type { EchoSchema } from '@dxos/echo-schema';
+import { promiseWithCauseCapture } from '@dxos/effect';
+import { BaseError } from '@dxos/errors';
+import { invariant } from '@dxos/invariant';
 import type { DXN } from '@dxos/keys';
 
 export class DatabaseService extends Context.Tag('@dxos/functions/DatabaseService')<
@@ -28,27 +33,96 @@ export class DatabaseService extends Context.Tag('@dxos/functions/DatabaseServic
     };
   };
 
-  static makeLayer = (db: EchoDatabase): Layer.Layer<DatabaseService> => {
+  static layer = (db: EchoDatabase): Layer.Layer<DatabaseService> => {
     return Layer.succeed(DatabaseService, DatabaseService.make(db));
   };
 
-  static resolve: (dxn: DXN) => Effect.Effect<Obj.Any | Relation.Any, Error, DatabaseService> = Effect.fn(
-    function* (dxn) {
+  /**
+   * Resolves an object by its DXN.
+   */
+  static resolve: {
+    // No type check.
+    (dxn: DXN): Effect.Effect<Obj.Any | Relation.Any, never, DatabaseService>;
+    // Check matches schema.
+    <S extends Type.Obj.Any | Type.Relation.Any>(
+      dxn: DXN,
+      schema: S,
+    ): Effect.Effect<Schema.Schema.Type<S>, ObjectNotFoundError, DatabaseService>;
+  } = (<S extends Type.Obj.Any | Type.Relation.Any>(
+    dxn: DXN,
+    schema?: S,
+  ): Effect.Effect<Schema.Schema.Type<S>, ObjectNotFoundError, DatabaseService> =>
+    Effect.gen(function* () {
       const { db } = yield* DatabaseService;
-      return yield* Effect.tryPromise({
-        try: () =>
-          db.graph.createRefResolver({ context: { space: db.spaceId } }).resolve(dxn) as Promise<
-            Obj.Any | Relation.Any
-          >,
-        catch: (error) => error as Error,
-      });
-    },
-  );
+      const object = yield* promiseWithCauseCapture(() =>
+        db.graph
+          .createRefResolver({
+            context: {
+              space: db.spaceId,
+            },
+          })
+          .resolve(dxn),
+      );
 
-  static loadRef: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, never, never> = Effect.fn(function* (ref) {
-    return yield* Effect.promise(() => ref.load());
+      if (!object) {
+        return yield* Effect.fail(new ObjectNotFoundError({ dxn }));
+      }
+      invariant(!schema || Obj.instanceOf(schema, object), 'Object type mismatch.');
+      return object as any;
+    })) as any;
+
+  /**
+   * Loads an object reference.
+   */
+  static load: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, ObjectNotFoundError, never> = Effect.fn(function* (ref) {
+    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
+    if (!object) {
+      return yield* Effect.fail(new ObjectNotFoundError({ dxn: ref.dxn }));
+    }
+    return object;
   });
 
+  /**
+   * Loads an object reference option.
+   */
+  // TODO(burdon): Option?
+  static loadOption: <T>(ref: Ref.Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(function* (ref) {
+    const object = yield* DatabaseService.load(ref).pipe(
+      Effect.catchTag('OBJECT_NOT_FOUND', () => Effect.succeed(undefined)),
+    );
+    return Option.fromNullable(object);
+  });
+
+  // TODO(burdon): Can we create a proxy for the following methods on EchoDatabase? Use @inheritDoc?
+  // TODO(burdon): Figure out how to chain query().run();
+
+  /**
+   * @link EchoDatabase.add
+   */
+  static add = <T extends Obj.Any | Relation.Any>(obj: T): Effect.Effect<T, never, DatabaseService> =>
+    DatabaseService.pipe(Effect.map(({ db }) => db.add(obj)));
+
+  /**
+   * @link EchoDatabase.remove
+   */
+  static remove = <T extends Obj.Any | Relation.Any>(obj: T): Effect.Effect<void, never, DatabaseService> =>
+    DatabaseService.pipe(Effect.map(({ db }) => db.remove(obj)));
+
+  /**
+   * @link EchoDatabase.flush
+   */
+  static flush = (opts?: FlushOptions) =>
+    DatabaseService.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));
+
+  /**
+   * @link EchoDatabase.getObjectById
+   */
+  static getObjectById = <T extends Obj.Any | Relation.Any>(
+    id: string,
+  ): Effect.Effect<Live<T> | undefined, never, DatabaseService> => {
+    return DatabaseService.pipe(Effect.map(({ db }) => db.getObjectById(id)));
+  };
+
   /**
    * Creates a `QueryResult` object that can be subscribed to.
    */
@@ -69,6 +143,28 @@ export class DatabaseService extends Context.Tag('@dxos/functions/DatabaseServic
     <F extends Filter.Any>(filter: F): Effect.Effect<OneShotQueryResult<Live<Filter.Type<F>>>, never, DatabaseService>;
   } = (queryOrFilter: Query.Any | Filter.Any) =>
     DatabaseService.query(queryOrFilter as any).pipe(
-      Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())),
+      Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),
     );
+
+  static schemaQuery = <Q extends SchemaRegistryQuery>(
+    query: Q,
+  ): Effect.Effect<SchemaRegistryPreparedQuery<EchoSchema>, never, DatabaseService> =>
+    DatabaseService.pipe(
+      Effect.map(({ db }) => db.schemaRegistry.query(query)),
+      Effect.withSpan('DatabaseService.schemaQuery'),
+    );
+
+  static runSchemaQuery = <Q extends SchemaRegistryQuery>(
+    query: Q,
+  ): Effect.Effect<EchoSchema[], never, DatabaseService> =>
+    DatabaseService.schemaQuery(query).pipe(
+      Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),
+    );
+}
+
+// TODO(burdon): Move to echo/errors.
+class ObjectNotFoundError extends BaseError.extend('OBJECT_NOT_FOUND') {
+  constructor(context?: Record<string, unknown>) {
+    super('Object not found', { context });
+  }
 }

package/src/services/event-logger.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Context, Schema, Layer } from 'effect';
+import { Context, Effect, Layer, Schema } from 'effect';
 
 import { Obj, Type } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
-import { log, LogLevel } from '@dxos/log';
+import { LogLevel, log } from '@dxos/log';
 
 import { TracingService } from './tracing';
 

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

@@ -6,43 +6,50 @@ import { Context, Effect, Layer, Schema } from 'effect';
 
 import { todo } from '@dxos/debug';
 
+import { FunctionError } from '../errors';
 import type { FunctionContext, FunctionDefinition } from '../handler';
+
 import type { Services } from './service-container';
-import { FunctionError } from '../errors';
 
 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(functionDef: FunctionDefinition<any, any>, input: unknown): Effect.Effect<unknown, never, Services>;
   }
 >() {
   static layer = Layer.succeed(LocalFunctionExecutionService, {
-    invokeFunction: (fnDef, input) => invokeFunction(fnDef, input),
+    invokeFunction: (functionDef, input) => invokeFunction(functionDef, input),
   });
+
+  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);
+    const assertInput = functionDef.inputSchema.pipe(Schema.asserts);
     (assertInput as any)(input);
 
     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.');
-      },
     };
 
     // 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 +65,13 @@ 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('Error running function', { context: { name: functionDef.name }, cause: defect })),
       ),
     );
 
     // Assert output matches schema
-    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
+    const assertOutput = functionDef.outputSchema?.pipe(Schema.asserts);
     (assertOutput as any)(data);
 
     return data;
-  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: fnDef.name } }));
+  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: functionDef.name } }));

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,45 @@ 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)));
 }
 
 /**
@@ -53,6 +70,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

@@ -6,6 +6,8 @@ import { Context, Layer } from 'effect';
 
 import type { SpaceId } from '@dxos/keys';
 
+import { getInvocationUrl } from '../url';
+
 /**
  * Allows calling into other functions.
  */
@@ -42,25 +44,3 @@ export class RemoteFunctionExecutionService extends Context.Tag('@dxos/functions
 
   static mockLayer = 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,14 +18,19 @@ 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);
 
@@ -31,14 +39,96 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
       // 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: () => ({}),
+        };
+      }),
+    );
+
   /**
    * Emit the current human-readable execution status.
    */
-  static emitStatus: (data: Obj.MakeProps<typeof AgentStatus>) => Effect.Effect<unknown, never, void> =
+  static emitStatus: (data: Obj.MakeProps<typeof AgentStatus>) => Effect.Effect<void, never, TracingService> =
     Effect.fnUntraced(function* (data) {
       const tracing = yield* TracingService;
-      tracing.write(Obj.make(AgentStatus, data));
+      tracing.write(
+        Obj.make(AgentStatus, {
+          parentMessage: tracing.getTraceContext().parentMessage,
+          toolCallId: tracing.getTraceContext().toolCallId,
+          ...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;
+  }
+}
+
+/**
+ * Goes into {@link DataType.Message['properties']}
+ */
+export const MESSAGE_PROPERTY_TOOL_CALL_ID = 'toolCallId' as const;

package/src/testing/layer.ts

@@ -2,27 +2,93 @@
 // 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[];
+  storagePath?: string;
 };
 
-export const TestDatabaseLayer = ({ indexing, types }: TestDatabaseOptions = {}) =>
+export const TestDatabaseLayer = ({ indexing, types, storagePath }: 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 = 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' }),
+          );
+        } 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());
+        queues = peer.client.constructQueueFactory(db.spaceId);
+      }
+
+      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';