@dxos/functions 0.8.4-main.72ec0f3 → 0.8.4-main.74a063c4e0

package/src/sdk.ts

@@ -2,14 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import type * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
 import { type AiService } from '@dxos/ai';
-import { Obj, Type } from '@dxos/echo';
-import { type DatabaseService } from '@dxos/echo-db';
-import { assertArgument, failedInvariant } from '@dxos/invariant';
+import { type Database, type Feed } from '@dxos/echo';
+import { type Trace } from '@dxos/functions';
 
 import {
   type CredentialsService,
@@ -17,8 +12,6 @@ import {
   type QueueService,
   type TracingService,
 } from './services';
-import { Function } from './types';
-import { getUserFunctionIdInMetadata, setUserFunctionIdInMetadata } from './types';
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
@@ -32,195 +25,15 @@ export type InvocationServices = TracingService;
 
 /**
  * Services that are available to invoked functions.
+ * @deprecated
  */
 export type FunctionServices =
   | InvocationServices
   | AiService.AiService
   | CredentialsService
-  | DatabaseService
+  | Database.Service
+  // TODO(wittjosiah): Remove QueueService — use Feed.FeedService instead.
   | QueueService
+  | Feed.FeedService
+  | Trace.TraceService
   | FunctionInvocationService;
-
-/**
- * Function handler.
- */
-export type FunctionHandler<TData = {}, TOutput = any, S extends FunctionServices = FunctionServices> = (params: {
-  /**
-   * Context available to the function.
-   */
-  context: FunctionContext;
-
-  /**
-   * Data passed as the input to the function.
-   * Must match the function's input schema.
-   * This will be the payload from the trigger or other data passed into the function in a workflow.
-   */
-  data: TData;
-}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, S>;
-
-/**
- * Function context.
- */
-export interface FunctionContext {
-  // TODO(dmaretskyi): Consider what we should put into context.
-}
-
-const typeId = Symbol.for('@dxos/functions/FunctionDefinition');
-
-export type FunctionDefinition<T = any, O = any, S extends FunctionServices = FunctionServices> = {
-  [typeId]: true;
-  key: string;
-  name: string;
-  description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, any>;
-
-  /**
-   * Keys of the required services.
-   */
-  services: readonly string[];
-
-  handler: FunctionHandler<T, O, S>;
-  meta?: {
-    /**
-     * Tools that are projected from functions have this annotation.
-     *
-     * deployedFunctionId:
-     * - Backend deployment ID assigned by the EDGE function service (typically a UUID).
-     * - Used for remote invocation via `FunctionInvocationService` → `RemoteFunctionExecutionService`.
-     * - Persisted on the corresponding ECHO `Function.Function` object's metadata under the
-     *   `FUNCTIONS_META_KEY` and retrieved with `getUserFunctionIdInMetadata`.
-     */
-    deployedFunctionId?: string;
-  };
-};
-
-export declare namespace FunctionDefinition {
-  export type Any = FunctionDefinition<any, any, any>;
-  export type Input<T extends Any> = T extends FunctionDefinition<infer I, infer _O, infer _S> ? I : never;
-  export type Output<T extends Any> = T extends FunctionDefinition<infer _I, infer O, infer _S> ? O : never;
-  export type Services<T extends Any> = T extends FunctionDefinition<infer _I, infer _O, infer S> ? S : never;
-}
-
-export type FunctionProps<T, O> = {
-  key: string;
-  name: string;
-  description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, any>;
-  // TODO(dmaretskyi): This currently doesn't cause a compile-time error if the handler requests a service that is not specified
-  services?: readonly Context.Tag<any, any>[];
-
-  handler: FunctionHandler<T, O, FunctionServices>;
-};
-
-// TODO(dmaretskyi): Output type doesn't get typechecked.
-export const defineFunction: {
-  <I, O>(params: FunctionProps<I, O>): FunctionDefinition<I, O, FunctionServices>;
-} = ({ key, name, description, inputSchema, outputSchema = Schema.Any, handler, services }) => {
-  if (!Schema.isSchema(inputSchema)) {
-    throw new Error('Input schema must be a valid schema');
-  }
-  if (typeof handler !== 'function') {
-    throw new Error('Handler must be a function');
-  }
-
-  // Captures the function definition location.
-  const limit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 2;
-  const traceError = new Error();
-  Error.stackTraceLimit = limit;
-  let cache: false | string = false;
-  const captureStackTrace = () => {
-    if (cache !== false) {
-      return cache;
-    }
-    if (traceError.stack !== undefined) {
-      const stack = traceError.stack.split('\n');
-      if (stack[2] !== undefined) {
-        cache = stack[2].trim();
-        return cache;
-      }
-    }
-  };
-
-  const handlerWithSpan = (...args: any[]) => {
-    const result = (handler as any)(...args);
-    if (Effect.isEffect(result)) {
-      return Effect.withSpan(result, `${key ?? name}`, {
-        captureStackTrace,
-      });
-    }
-    return result;
-  };
-
-  return {
-    [typeId]: true,
-    key,
-    name,
-    description,
-    inputSchema,
-    outputSchema,
-    handler: handlerWithSpan,
-    services: !services ? [] : getServiceKeys(services),
-  } satisfies FunctionDefinition.Any;
-};
-
-const getServiceKeys = (services: readonly Context.Tag<any, any>[]) => {
-  return services.map((tag: any) => {
-    if (typeof tag.key === 'string') {
-      return tag.key;
-    }
-    console.log(tag);
-    failedInvariant();
-  });
-};
-
-export const FunctionDefinition = {
-  make: defineFunction,
-  isFunction: (value: unknown): value is FunctionDefinition.Any => {
-    return typeof value === 'object' && value !== null && Symbol.for('@dxos/functions/FunctionDefinition') in value;
-  },
-  serialize: (functionDef: FunctionDefinition.Any): Function.Function => {
-    assertArgument(FunctionDefinition.isFunction(functionDef), 'functionDef');
-    return serializeFunction(functionDef);
-  },
-  deserialize: (functionObj: Function.Function): FunctionDefinition.Any => {
-    assertArgument(Obj.instanceOf(Function.Function, functionObj), 'functionObj');
-    return deserializeFunction(functionObj);
-  },
-};
-
-export const serializeFunction = (functionDef: FunctionDefinition.Any): Function.Function => {
-  const fn = Function.make({
-    key: functionDef.key,
-    name: functionDef.name,
-    version: '0.1.0',
-    description: functionDef.description,
-    inputSchema: Type.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? undefined : Type.toJsonSchema(functionDef.outputSchema),
-    services: functionDef.services,
-  });
-  if (functionDef.meta?.deployedFunctionId) {
-    setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta.deployedFunctionId);
-  }
-  return fn;
-};
-
-export const deserializeFunction = (functionObj: Function.Function): FunctionDefinition<unknown, unknown> => {
-  return {
-    [typeId]: true,
-    // TODO(dmaretskyi): Fix key.
-    key: functionObj.key ?? functionObj.name,
-    name: functionObj.name,
-    description: functionObj.description,
-    inputSchema: !functionObj.inputSchema ? Schema.Unknown : Type.toEffectSchema(functionObj.inputSchema),
-    outputSchema: !functionObj.outputSchema ? undefined : Type.toEffectSchema(functionObj.outputSchema),
-    // TODO(dmaretskyi): This should throw error.
-    handler: () => {},
-    services: functionObj.services ?? [],
-    meta: {
-      deployedFunctionId: getUserFunctionIdInMetadata(Obj.getMeta(functionObj)),
-    },
-  };
-};

package/src/services/credentials.ts

@@ -11,7 +11,7 @@ import * as Layer from 'effect/Layer';
 import * as Redacted from 'effect/Redacted';
 
 import { Query } from '@dxos/echo';
-import { DatabaseService } from '@dxos/echo-db';
+import { Database } from '@dxos/echo';
 import { AccessToken } from '@dxos/types';
 
 export type CredentialQuery = {
@@ -60,7 +60,12 @@ export class CredentialsService extends Context.Tag('@dxos/functions/Credentials
   static configuredLayer = (credentials: ServiceCredential[]) =>
     Layer.succeed(CredentialsService, new ConfiguredCredentialsService(credentials));
 
-  static layerConfig = (credentials: { service: string; apiKey: Config.Config<Redacted.Redacted<string>> }[]) =>
+  static layerConfig = (
+    credentials: {
+      service: string;
+      apiKey: Config.Config<Redacted.Redacted<string>>;
+    }[],
+  ) =>
     Layer.effect(
       CredentialsService,
       Effect.gen(function* () {
@@ -77,20 +82,34 @@ export class CredentialsService extends Context.Tag('@dxos/functions/Credentials
       }),
     );
 
-  static layerFromDatabase = () =>
+  static layerFromDatabase = ({ caching = false }: { caching?: boolean } = {}) =>
     Layer.effect(
       CredentialsService,
       Effect.gen(function* () {
-        const dbService = yield* DatabaseService;
+        const dbService = yield* Database.Service;
+        const cache = new Map<string, ServiceCredential[]>();
+
         const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
-          const { objects: accessTokens } = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
-          return accessTokens
+          const cacheKey = JSON.stringify(query);
+          if (caching && cache.has(cacheKey)) {
+            return cache.get(cacheKey)!;
+          }
+
+          const accessTokens = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
+          const credentials = accessTokens
             .filter((accessToken) => accessToken.source === query.service)
             .map((accessToken) => ({
               service: accessToken.source,
               apiKey: accessToken.token,
             }));
+
+          if (caching) {
+            cache.set(cacheKey, credentials);
+          }
+
+          return credentials;
         };
+
         return {
           getCredential: async (query) => {
             const credentials = await queryCredentials(query);
@@ -131,13 +150,10 @@ export class ConfiguredCredentialsService implements Context.Tag.Service<Credent
 }
 
 /**
- * Maps the request to include the API key from the credential.
+ * Maps the request to include the given token in the Authorization header.
  */
-export const withAuthorization = (query: CredentialQuery, kind?: 'Bearer' | 'Basic') =>
-  HttpClient.mapRequestEffect(
-    Effect.fnUntraced(function* (request) {
-      const key = yield* CredentialsService.getApiKey(query).pipe(Effect.map(Redacted.value));
-      const authorization = kind ? `${kind} ${key}` : key;
-      return HttpClientRequest.setHeader(request, 'Authorization', authorization);
-    }),
-  );
+export const withAuthorization = (token: string, kind?: 'Bearer' | 'Basic') =>
+  HttpClient.mapRequest((request) => {
+    const authorization = kind ? `${kind} ${token}` : token;
+    return HttpClientRequest.setHeader(request, 'Authorization', authorization);
+  });

package/src/services/event-logger.ts

@@ -52,7 +52,7 @@ export type ComputeEventPayload = Schema.Schema.Type<typeof ComputeEventPayload>
 
 export const ComputeEvent = Schema.Struct({
   payload: ComputeEventPayload,
-}).pipe(Type.Obj({ typename: 'dxos.org/type/ComputeEvent', version: '0.1.0' }));
+}).pipe(Type.object({ typename: 'org.dxos.type.computeEvent', version: '0.1.0' }));
 
 /**
  * Logs event for the compute workflows.
@@ -75,7 +75,7 @@ export class ComputeEventLogger extends Context.Tag('@dxos/functions/ComputeEven
       const tracing = yield* TracingService;
       return {
         log: (event: ComputeEventPayload) => {
-          tracing.write(Obj.make(ComputeEvent, { payload: event }));
+          tracing.write(Obj.make(ComputeEvent, { payload: event }), tracing.getTraceContext());
         },
         nodeId: undefined,
       };

package/src/services/function-invocation-service.ts

@@ -3,21 +3,37 @@
 //
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
-import { type FunctionDefinition, type InvocationServices } from '../sdk';
+import { Operation } from '@dxos/operation';
+
+import type { FunctionNotFoundError } from '../errors';
+import { type InvocationServices } from '../sdk';
 
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
   FunctionInvocationService,
   {
     invokeFunction<I, O>(
-      functionDef: FunctionDefinition<I, O, any>,
+      functionDef: Operation.Definition<I, O, any>,
       input: I,
     ): Effect.Effect<O, never, InvocationServices>;
+
+    resolveFunction(key: string): Effect.Effect<Operation.Definition.Any, FunctionNotFoundError>;
   }
 >() {
+  static layerNotAvailable = Layer.succeed(FunctionInvocationService, {
+    invokeFunction: () => Effect.die('FunctionInvocationService is not avaialble.'),
+    resolveFunction: () => Effect.die('FunctionInvocationService is not available.'),
+  });
+
   static invokeFunction = <I, O>(
-    functionDef: FunctionDefinition<I, O, any>,
+    functionDef: Operation.Definition<I, O, any>,
     input: I,
   ): Effect.Effect<O, never, FunctionInvocationService | InvocationServices> =>
     Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+
+  static resolveFunction = (
+    key: string,
+  ): Effect.Effect<Operation.Definition.Any, FunctionNotFoundError, FunctionInvocationService> =>
+    Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.resolveFunction)(key);
 }

package/src/services/index.ts

@@ -2,8 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-export { DatabaseService } from '@dxos/echo-db';
-
 export * from './credentials';
 export { ConfiguredCredentialsService, type ServiceCredential } from './credentials';
 export * from './event-logger';

package/src/services/queues.ts

@@ -6,12 +6,13 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import type { Obj, Relation } from '@dxos/echo';
-import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
+import { type Entity } from '@dxos/echo';
+import { createFeedServiceLayer, type Queue, type QueueAPI, type QueueFactory } from '@dxos/echo-db';
 import type { DXN, QueueSubspaceTag } from '@dxos/keys';
 
 /**
  * Gives access to all queues.
+ * @deprecated Use Feed.FeedService instead.
  */
 export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
   QueueService,
@@ -53,26 +54,25 @@ export class QueueService extends Context.Tag('@dxos/functions/QueueService')<
   /**
    * Gets a queue by its DXN.
    */
-  static getQueue = <T extends Obj.Any | Relation.Any = Obj.Any | Relation.Any>(
+  static getQueue = <T extends Entity.Unknown = Entity.Unknown>(
     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?: {
+  static createQueue = <T extends Entity.Unknown = Entity.Unknown>(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));
+  static append = <T extends Entity.Unknown = Entity.Unknown>(queue: Queue<T>, objects: T[]): Effect.Effect<void> =>
+    Effect.promise(() => queue.append(objects));
 }
 
 /**
  * Gives access to a specific queue passed as a context.
+ * @deprecated Use Feed.FeedService instead.
  */
 export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQueueService')<
   ContextQueueService,
@@ -82,3 +82,10 @@ export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQue
 >() {
   static layer = (queue: Queue) => Layer.succeed(ContextQueueService, { queue });
 }
+
+export const feedServiceFromQueueServiceLayer = Layer.unwrapEffect(
+  Effect.gen(function* () {
+    const { queues } = yield* QueueService;
+    return createFeedServiceLayer(queues);
+  }),
+);

package/src/services/tracing.ts

@@ -7,13 +7,16 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
 import { AgentStatus } from '@dxos/ai';
-import { Obj } from '@dxos/echo';
-import type { ObjectId } from '@dxos/echo/internal';
+import { type DXN, Obj, Ref } from '@dxos/echo';
+import { ObjectId } from '@dxos/keys';
 import { Message } from '@dxos/types';
 
+import type { Trigger } from '../types';
+
 /**
  * Provides a way for compute primitives (functions, workflows, tools)
  * to emit an execution trace as a series of structured ECHO objects.
+ * @deprecated Use Trace.TraceService instead.
  */
 export class TracingService extends Context.Tag('@dxos/functions/TracingService')<
   TracingService,
@@ -27,15 +30,41 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
      * Write an event to the tracing queue.
      * @param event - The event to write. Must be an a typed object.
      */
-    write: (event: Obj.Any) => void;
+    write: (event: Obj.Unknown, traceContext: TracingService.TraceContext) => void;
+
+    /**
+     * Write an ephemeral event.
+     */
+    ephemeral: (event: Obj.Unknown, traceContext: TracingService.TraceContext) => void;
+
+    traceInvocationStart({
+      payload,
+      target,
+    }: {
+      payload: TracingService.FunctionInvocationPayload;
+      target?: DXN;
+    }): Effect.Effect<TracingService.InvocationTraceData>;
+
+    traceInvocationEnd({
+      trace,
+      exception,
+    }: {
+      trace: TracingService.InvocationTraceData;
+      exception?: any;
+    }): Effect.Effect<void>;
   }
 >() {
   static noop: Context.Tag.Service<TracingService> = {
     getTraceContext: () => ({}),
     write: () => {},
+    ephemeral: () => {},
+    traceInvocationStart: () =>
+      Effect.sync(() => ({ invocationId: ObjectId.random(), invocationTraceQueue: undefined })),
+    traceInvocationEnd: () => Effect.sync(() => {}),
   };
 
   static layerNoop: Layer.Layer<TracingService> = Layer.succeed(TracingService, TracingService.noop);
+
   /**
    * Creates a TracingService layer that emits events to the parent tracing service.
    */
@@ -46,12 +75,26 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
         const tracing = yield* TracingService;
         const context = mapContext(tracing.getTraceContext());
         return {
-          write: (event) => tracing.write(event),
+          write: (event, context) => tracing.write(event, context),
+          ephemeral: (event, context) => tracing.ephemeral(event, context),
           getTraceContext: () => context,
+          traceInvocationStart: () => Effect.die('Tracing invocation inside another invocation is not supported.'),
+          traceInvocationEnd: () => Effect.die('Tracing invocation inside another invocation is not supported.'),
         };
       }),
     );
 
+  /**
+   * Create sublayer to trace an invocation.
+   * @param data
+   * @returns
+   */
+  static layerInvocation = (data: TracingService.InvocationTraceData) =>
+    TracingService.layerSubframe((context) => ({
+      ...context,
+      currentInvocation: data,
+    }));
+
   /**
    * Emit the current human-readable execution status.
    */
@@ -66,11 +109,12 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
         created: new Date().toISOString(),
         ...data,
       }),
+      tracing.getTraceContext(),
     );
   });
 
   static emitConverationMessage: (
-    data: Obj.MakeProps<typeof Message.Message>,
+    data: Obj.MakeProps<typeof Message.Message> | Message.Message,
   ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
     const tracing = yield* TracingService;
     tracing.write(
@@ -82,12 +126,21 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
           ...data.properties,
         },
       }),
+      tracing.getTraceContext(),
     );
   });
+
+  static emitEphemeralMessage: (data: Message.Message) => Effect.Effect<void, never, TracingService> =
+    Effect.fnUntraced(function* (data) {
+      const tracing = yield* TracingService;
+      tracing.ephemeral(data, tracing.getTraceContext());
+    });
 }
 
 export namespace TracingService {
   export interface TraceContext {
+    currentInvocation?: InvocationTraceData;
+
     /**
      * If this thread sprung from a tool call, this is the ID of the message containing the tool call.
      */
@@ -100,6 +153,45 @@ export namespace TracingService {
 
     debugInfo?: unknown;
   }
+
+  /**
+   * Trace data for a function/trigger invocation.
+   */
+  export interface InvocationTraceData {
+    invocationId: ObjectId;
+    invocationTraceQueue?: DXN.String;
+  }
+
+  /**
+   * Payload for a function/trigger invocation.
+   */
+  export interface FunctionInvocationPayload {
+    data?: any;
+    inputNodeId?: string;
+    trigger?: {
+      id: string;
+      kind: Trigger.Kind;
+    };
+    chat?: Ref.Ref<Obj.Unknown>;
+    process?: {
+      pid: string;
+      parentPid?: string;
+      /**
+       * Key of the executable.
+       */
+      key: string;
+
+      /**
+       * Process name.
+       */
+      name?: string;
+
+      /**
+       * Target object that the process is assigned to.
+       */
+      target?: string;
+    };
+  }
 }
 
 /**

package/src/types/Script.ts

@@ -4,8 +4,8 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Obj, Ref, Type } from '@dxos/echo';
-import { FormAnnotation, LabelAnnotation } from '@dxos/echo/internal';
+import { Annotation, Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation } from '@dxos/echo/internal';
 import { Text } from '@dxos/schema';
 
 /**
@@ -16,18 +16,23 @@ export const Script = Schema.Struct({
   description: Schema.String.pipe(Schema.optional),
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
-  changed: Schema.Boolean.pipe(FormAnnotation.set(false), Schema.optional),
-  source: Type.Ref(Text.Text).pipe(FormAnnotation.set(false)),
+  changed: Schema.Boolean.pipe(FormInputAnnotation.set(false), Schema.optional),
+  source: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
 }).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Script',
+  Type.object({
+    typename: 'org.dxos.type.script',
     version: '0.1.0',
   }),
-  LabelAnnotation.set(['name']),
+  Annotation.LabelAnnotation.set(['name']),
+  Annotation.IconAnnotation.set({
+    icon: 'ph--code--regular',
+    hue: 'sky',
+  }),
 );
+
 export interface Script extends Schema.Schema.Type<typeof Script> {}
 
 type Props = Omit<Obj.MakeProps<typeof Script>, 'source'> & { source?: string };
 
-export const make = ({ source = '', ...props }: Props = {}) =>
-  Obj.make(Script, { ...props, source: Ref.make(Text.make(source)) });
+export const make = ({ source = '', ...props }: Props = {}): Script =>
+  Obj.make(Script, { ...props, source: Ref.make(Text.make({ content: source })) });