@dxos/functions 0.8.4-main.c1de068 → 0.8.4-main.fd6878d

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.c1de068",
+  "version": "0.8.4-main.fd6878d",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -10,21 +10,25 @@
   "type": "module",
   "exports": {
     "./bundler": {
+      "source": "./src/bundler/index.ts",
       "types": "./dist/types/src/bundler/index.d.ts",
       "browser": "./dist/lib/browser/bundler/index.mjs",
       "node": "./dist/lib/node-esm/bundler/index.mjs"
     },
     "./edge": {
+      "source": "./src/edge/index.ts",
       "types": "./dist/types/src/edge/index.d.ts",
       "browser": "./dist/lib/browser/edge/index.mjs",
       "node": "./dist/lib/node-esm/edge/index.mjs"
     },
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
     },
     "./testing": {
+      "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
       "browser": "./dist/lib/browser/testing/index.mjs",
       "node": "./dist/lib/node-esm/testing/index.mjs"
@@ -47,43 +51,44 @@
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.89.0",
+    "@effect/platform": "0.90.2",
     "@preact/signals-core": "^1.9.0",
     "cron": "^3.1.6",
     "cron-schedule": "^5.0.4",
-    "effect": "3.17.0",
+    "effect": "3.17.7",
     "esbuild-wasm": "^0.16.14",
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
     "i18next": "^24.2.1",
     "iso-did": "^1.6.0",
     "ws": "^8.14.2",
-    "@dxos/ai": "0.8.4-main.c1de068",
-    "@dxos/client": "0.8.4-main.c1de068",
-    "@dxos/async": "0.8.4-main.c1de068",
-    "@dxos/context": "0.8.4-main.c1de068",
-    "@dxos/echo": "0.8.4-main.c1de068",
-    "@dxos/crypto": "0.8.4-main.c1de068",
-    "@dxos/echo-db": "0.8.4-main.c1de068",
-    "@dxos/echo-pipeline": "0.8.4-main.c1de068",
-    "@dxos/echo-protocol": "0.8.4-main.c1de068",
-    "@dxos/edge-client": "0.8.4-main.c1de068",
-    "@dxos/echo-schema": "0.8.4-main.c1de068",
-    "@dxos/errors": "0.8.4-main.c1de068",
-    "@dxos/effect": "0.8.4-main.c1de068",
-    "@dxos/invariant": "0.8.4-main.c1de068",
-    "@dxos/keys": "0.8.4-main.c1de068",
-    "@dxos/live-object": "0.8.4-main.c1de068",
-    "@dxos/log": "0.8.4-main.c1de068",
-    "@dxos/node-std": "0.8.4-main.c1de068",
-    "@dxos/schema": "0.8.4-main.c1de068",
-    "@dxos/protocols": "0.8.4-main.c1de068",
-    "@dxos/util": "0.8.4-main.c1de068"
+    "@dxos/ai": "0.8.4-main.fd6878d",
+    "@dxos/async": "0.8.4-main.fd6878d",
+    "@dxos/debug": "0.8.4-main.fd6878d",
+    "@dxos/crypto": "0.8.4-main.fd6878d",
+    "@dxos/client": "0.8.4-main.fd6878d",
+    "@dxos/echo": "0.8.4-main.fd6878d",
+    "@dxos/echo-db": "0.8.4-main.fd6878d",
+    "@dxos/echo-pipeline": "0.8.4-main.fd6878d",
+    "@dxos/echo-schema": "0.8.4-main.fd6878d",
+    "@dxos/echo-protocol": "0.8.4-main.fd6878d",
+    "@dxos/edge-client": "0.8.4-main.fd6878d",
+    "@dxos/effect": "0.8.4-main.fd6878d",
+    "@dxos/errors": "0.8.4-main.fd6878d",
+    "@dxos/invariant": "0.8.4-main.fd6878d",
+    "@dxos/live-object": "0.8.4-main.fd6878d",
+    "@dxos/keys": "0.8.4-main.fd6878d",
+    "@dxos/log": "0.8.4-main.fd6878d",
+    "@dxos/node-std": "0.8.4-main.fd6878d",
+    "@dxos/context": "0.8.4-main.fd6878d",
+    "@dxos/schema": "0.8.4-main.fd6878d",
+    "@dxos/protocols": "0.8.4-main.fd6878d",
+    "@dxos/util": "0.8.4-main.fd6878d"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.4-main.c1de068"
+    "@dxos/agent": "0.8.4-main.fd6878d"
   },
   "publishConfig": {
     "access": "public"

package/src/bundler/bundler.ts

@@ -3,8 +3,8 @@
 //
 
 import { FetchHttpClient, HttpClient } from '@effect/platform';
-import { Duration, Effect, pipe, Schedule } from 'effect';
-import { type BuildOptions, type Loader, build, initialize, type BuildResult, type Plugin } from 'esbuild-wasm';
+import { Duration, Effect, Schedule, pipe } from 'effect';
+import { type BuildOptions, type BuildResult, type Loader, type Plugin, build, initialize } from 'esbuild-wasm';
 
 import { subtleCrypto } from '@dxos/crypto';
 import { runAndForwardErrors } from '@dxos/effect';

package/src/executor/executor.ts

@@ -4,7 +4,7 @@
 
 import { Effect, Schema } from 'effect';
 
-import type { SpaceId } from '@dxos/client/echo';
+import { type SpaceId } from '@dxos/client/echo';
 import { runAndForwardErrors } from '@dxos/effect';
 
 import type { FunctionContext, FunctionDefinition } from '../handler';
@@ -13,6 +13,9 @@ import type { ServiceContainer, Services } from '../services';
 export class FunctionExecutor {
   constructor(private readonly _services: ServiceContainer) {}
 
+  /**
+   *
+   */
   // TODO(dmaretskyi): Invocation context: queue, space, etc...
   async invoke<F extends FunctionDefinition<any, any>>(
     fnDef: F,
@@ -23,14 +26,11 @@ export class FunctionExecutor {
     (assertInput as any)(input);
 
     const context: FunctionContext = {
+      space: undefined,
       getService: this._services.getService.bind(this._services),
       getSpace: async (_spaceId: SpaceId) => {
         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.');
-      },
     };
 
     const result = fnDef.handler({ context, data: input });

package/src/handler.ts

@@ -2,13 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema, type Context, type Effect } from 'effect';
+import { type Context, type Effect, Schema } from 'effect';
 
-import { type AiServiceClient } from '@dxos/ai';
-// import { type Space } from '@dxos/client/echo';
-import type { EchoDatabase } from '@dxos/echo-db';
+import { type EchoDatabase } from '@dxos/echo-db';
 import { type HasId } from '@dxos/echo-schema';
-import { type SpaceId, type DXN } from '@dxos/keys';
+import { type DXN, type SpaceId } from '@dxos/keys';
 import { type QueryResult } from '@dxos/protocols';
 
 import type { Services } from './services';
@@ -44,8 +42,6 @@ export interface FunctionContext {
    */
   space: SpaceAPI | undefined;
 
-  ai: AiServiceClient;
-
   /**
    * Resolves a service available to the function.
    * @throws if the service is not available.
@@ -118,3 +114,9 @@ export const defineFunction = <T, O>({
     handler,
   };
 };
+
+export namespace FunctionDefinition {
+  export type Any = FunctionDefinition<any, any>;
+  export type Input<T extends FunctionDefinition> = T extends FunctionDefinition<infer I, any> ? I : never;
+  export type Output<T extends FunctionDefinition> = T extends FunctionDefinition<any, infer O> ? O : never;
+}

package/src/services/credentials.ts

@@ -2,7 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect } from 'effect';
+import { Context, Effect, Layer } from 'effect';
+
+import { Query } from '@dxos/echo';
+import { DataType } from '@dxos/schema';
+
+import { DatabaseService } from './database';
 
 type CredentialQuery = {
   service?: string;
@@ -17,7 +22,7 @@ export type ServiceCredential = {
   apiKey?: string;
 };
 
-export class CredentialsService extends Context.Tag('CredentialsService')<
+export class CredentialsService extends Context.Tag('@dxos/functions/CredentialsService')<
   CredentialsService,
   {
     /**
@@ -37,6 +42,38 @@ export class CredentialsService extends Context.Tag('CredentialsService')<
       const credentials = yield* CredentialsService;
       return yield* Effect.promise(() => credentials.getCredential(query));
     });
+
+  static configuredLayer = (credentials: ServiceCredential[]) =>
+    Layer.succeed(CredentialsService, new ConfiguredCredentialsService(credentials));
+
+  static layerFromDatabase = () =>
+    Layer.effect(
+      CredentialsService,
+      Effect.gen(function* () {
+        const dbService = yield* DatabaseService;
+        const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
+          const { objects: accessTokens } = await dbService.db.query(Query.type(DataType.AccessToken)).run();
+          return accessTokens
+            .filter((accessToken) => accessToken.source === query.service)
+            .map((accessToken) => ({
+              service: accessToken.source,
+              apiKey: accessToken.token,
+            }));
+        };
+        return {
+          getCredential: async (query) => {
+            const credentials = await queryCredentials(query);
+            if (credentials.length === 0) {
+              throw new Error(`Credential not found for service: ${query.service}`);
+            }
+            return credentials[0];
+          },
+          queryCredentials: async (query) => {
+            return queryCredentials(query);
+          },
+        };
+      }),
+    );
 }
 
 export class ConfiguredCredentialsService implements Context.Tag.Service<CredentialsService> {

package/src/services/database.ts

@@ -2,13 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer } from 'effect';
+import { Context, Effect, Layer, 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 } from '@dxos/echo-db';
+import { BaseError } from '@dxos/errors';
+import { invariant } from '@dxos/invariant';
 import type { DXN } from '@dxos/keys';
 
-export class DatabaseService extends Context.Tag('DatabaseService')<
+export class DatabaseService extends Context.Tag('@dxos/functions/DatabaseService')<
   DatabaseService,
   {
     readonly db: EchoDatabase;
@@ -28,20 +30,48 @@ export class DatabaseService extends Context.Tag('DatabaseService')<
     };
   };
 
-  static resolve: (dxn: DXN) => Effect.Effect<Obj.Any | Relation.Any, Error, DatabaseService> = Effect.fn(
-    function* (dxn) {
+  static layer = (db: EchoDatabase): Layer.Layer<DatabaseService> => {
+    return Layer.succeed(DatabaseService, DatabaseService.make(db));
+  };
+
+  /**
+   * 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* Effect.promise(() =>
+        db.graph
+          .createRefResolver({
+            context: {
+              space: db.spaceId,
+            },
+          })
+          .resolve(dxn),
+      );
+
+      if (!object) {
+        return yield* Effect.fail(new ObjectNotFoundError({ dxn }));
+      }
+      invariant(!schema || Obj.instanceOf(schema, object), 'Object type mismatch.');
+      return object as any;
+    })) as any;
 
-  static loadRef: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, never, never> = Effect.fn(function* (ref) {
+  /**
+   * Loads an object reference.
+   */
+  static load: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, never, never> = Effect.fn(function* (ref) {
     return yield* Effect.promise(() => ref.load());
   });
 
@@ -67,4 +97,20 @@ export class DatabaseService extends Context.Tag('DatabaseService')<
     DatabaseService.query(queryOrFilter as any).pipe(
       Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())),
     );
+
+  /**
+   * Adds an object to the database.
+   */
+  static add = <T extends Obj.Any | Relation.Any>(obj: T): Effect.Effect<T, never, DatabaseService> =>
+    DatabaseService.pipe(Effect.map(({ db }) => db.add(obj)));
+
+  static flush = (opts?: FlushOptions) =>
+    DatabaseService.pipe(Effect.flatMap(({ db }) => Effect.promise(() => db.flush(opts))));
+}
+
+// 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,53 +2,81 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Effect, Context } 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';
 
-export type ComputeEvent =
-  | {
-      type: 'begin-compute';
-      nodeId: string;
-      inputs: Record<string, any>;
-    }
-  | {
-      type: 'end-compute';
-      nodeId: string;
-      outputs: Record<string, any>;
-    }
-  | {
-      type: 'compute-input';
-      nodeId: string;
-      property: string;
-      value: any;
-    }
-  | {
-      type: 'compute-output';
-      nodeId: string;
-      property: string;
-      value: any;
-    }
-  | {
-      type: 'custom';
-      nodeId: string;
-      event: any;
-    };
+import { TracingService } from './tracing';
+
+export const ComputeEventPayload = Schema.Union(
+  Schema.Struct({
+    type: Schema.Literal('begin-compute'),
+    nodeId: Schema.String,
+    inputs: Schema.Record({ key: Schema.String, value: Schema.Any }),
+  }),
+  Schema.Struct({
+    type: Schema.Literal('end-compute'),
+    nodeId: Schema.String,
+    outputs: Schema.Record({ key: Schema.String, value: Schema.Any }),
+  }),
+  Schema.Struct({
+    type: Schema.Literal('compute-input'),
+    nodeId: Schema.String,
+    property: Schema.String,
+    value: Schema.Any,
+  }),
+  Schema.Struct({
+    type: Schema.Literal('compute-output'),
+    nodeId: Schema.String,
+    property: Schema.String,
+    value: Schema.Any,
+  }),
+  Schema.Struct({
+    type: Schema.Literal('custom'),
+    nodeId: Schema.String,
+    event: Schema.Any,
+  }),
+);
+export type ComputeEventPayload = Schema.Schema.Type<typeof ComputeEventPayload>;
 
-export class EventLogger extends Context.Tag('EventLogger')<
-  EventLogger,
-  { readonly log: (event: ComputeEvent) => void; readonly nodeId: string | undefined }
+export const ComputeEvent = Schema.Struct({
+  payload: ComputeEventPayload,
+}).pipe(Type.Obj({ typename: 'dxos.org/type/ComputeEvent', version: '0.1.0' }));
+
+/**
+ * Logs event for the compute workflows.
+ */
+export class ComputeEventLogger extends Context.Tag('@dxos/functions/ComputeEventLogger')<
+  ComputeEventLogger,
+  { readonly log: (event: ComputeEventPayload) => void; readonly nodeId: string | undefined }
 >() {
-  static noop: Context.Tag.Service<EventLogger> = {
+  static noop: Context.Tag.Service<ComputeEventLogger> = {
     log: () => {},
     nodeId: undefined,
   };
+
+  /**
+   * Implements ComputeEventLogger using TracingService.
+   */
+  static layerFromTracing = Layer.effect(
+    ComputeEventLogger,
+    Effect.gen(function* () {
+      const tracing = yield* TracingService;
+      return {
+        log: (event: ComputeEventPayload) => {
+          tracing.write(Obj.make(ComputeEvent, { payload: event }));
+        },
+        nodeId: undefined,
+      };
+    }),
+  );
 }
 
 export const logCustomEvent = (data: any) =>
   Effect.gen(function* () {
-    const logger = yield* EventLogger;
+    const logger = yield* ComputeEventLogger;
     if (!logger.nodeId) {
       throw new Error('logCustomEvent must be called within a node compute function');
     }
@@ -67,7 +95,10 @@ export const createDefectLogger = <A, E, R>(): ((self: Effect.Effect<A, E, R>) =
     }),
   );
 
-export const createEventLogger = (level: LogLevel, message: string = 'event'): Context.Tag.Service<EventLogger> => {
+export const createEventLogger = (
+  level: LogLevel,
+  message: string = 'event',
+): Context.Tag.Service<ComputeEventLogger> => {
   const logFunction = (
     {
       [LogLevel.WARN]: log.warn,
@@ -79,7 +110,7 @@ export const createEventLogger = (level: LogLevel, message: string = 'event'): C
   )[level];
   invariant(logFunction);
   return {
-    log: (event: ComputeEvent) => {
+    log: (event: ComputeEventPayload) => {
       logFunction(message, event);
     },
     nodeId: undefined,

package/src/services/index.ts

@@ -8,4 +8,5 @@ export * from './service-container';
 export * from './credentials';
 export * from './tracing';
 export * from './event-logger';
-export * from './function-call-service';
+export * from './remote-function-execution-service';
+export * from './local-function-execution';

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

@@ -0,0 +1,74 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+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';
+
+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>;
+  }
+>() {
+  static layer = Layer.succeed(LocalFunctionExecutionService, {
+    invokeFunction: (fnDef, input) => invokeFunction(fnDef, input),
+  });
+
+  static invokeFunction: <F extends FunctionDefinition.Any>(
+    fnDef: 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> =>
+  Effect.gen(function* () {
+    // Assert input matches schema
+    const assertInput = fnDef.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.');
+      },
+    };
+
+    // TODO(dmaretskyi): This should be delegated to a function invoker service.
+    const data = yield* Effect.gen(function* () {
+      const result = fnDef.handler({ context, data: input });
+      if (Effect.isEffect(result)) {
+        return yield* (result as Effect.Effect<unknown, unknown, Services>).pipe(Effect.orDie);
+      } else if (
+        typeof result === 'object' &&
+        result !== null &&
+        'then' in result &&
+        typeof result.then === 'function'
+      ) {
+        return yield* Effect.promise(() => result);
+      } else {
+        return result;
+      }
+    }).pipe(
+      Effect.orDie,
+      Effect.catchAllDefect((defect) =>
+        Effect.die(new FunctionError('Error running function', { context: { name: fnDef.name }, cause: defect })),
+      ),
+    );
+
+    // Assert output matches schema
+    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
+    (assertOutput as any)(data);
+
+    return data;
+  }).pipe(Effect.withSpan('invokeFunction', { attributes: { name: fnDef.name } }));

package/src/services/queues.ts

@@ -2,14 +2,16 @@
 // 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.
  */
-export class QueueService extends Context.Tag('QueueService')<
+export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
   QueueService,
   {
     /**
@@ -21,35 +23,55 @@ export class QueueService extends Context.Tag('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 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)));
 }
 
 /**
  * Gives access to a specific queue passed as a context.
  */
-export class ContextQueueService extends Context.Tag('ContextQueueService')<
+export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQueueService')<
   ContextQueueService,
   {
-    readonly contextQueue: Queue;
+    readonly queue: Queue;
   }
->() {}
+>() {
+  static layer = (queue: Queue) => Layer.succeed(ContextQueueService, { queue });
+}