@dxos/functions 0.8.4-main.ead640a → 0.8.4-main.ef1bc66f44

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

@@ -5,80 +5,33 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import { AiService } from '@dxos/ai';
-
-import { type FunctionDefinition } from '../handler';
-
-import { CredentialsService } from './credentials';
-import { DatabaseService } from './database';
-import {
-  FunctionImplementationResolver,
-  type InvocationServices,
-  LocalFunctionExecutionService,
-} from './local-function-execution';
-import { QueueService } from './queues';
-import { RemoteFunctionExecutionService } from './remote-function-execution-service';
+import type { FunctionNotFoundError } from '../errors';
+import { type FunctionDefinition, type InvocationServices } from '../sdk';
 
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
   FunctionInvocationService,
   {
-    invokeFunction<I, O>(functionDef: FunctionDefinition<I, O>, input: I): Effect.Effect<O, never, InvocationServices>;
+    invokeFunction<I, O>(
+      functionDef: FunctionDefinition<I, O, any>,
+      input: I,
+    ): Effect.Effect<O, never, InvocationServices>;
+
+    resolveFunction(key: string): Effect.Effect<FunctionDefinition.Any, FunctionNotFoundError>;
   }
 >() {
-  static invokeFunction = Effect.serviceFunctionEffect(FunctionInvocationService, (_) => _.invokeFunction);
-
-  static layer = Layer.effect(
-    FunctionInvocationService,
-    Effect.gen(function* () {
-      const localExecutioner = yield* LocalFunctionExecutionService;
-      const remoteExecutioner = yield* RemoteFunctionExecutionService;
-
-      return {
-        invokeFunction: <I, O>(
-          functionDef: FunctionDefinition<I, O>,
-          input: I,
-        ): Effect.Effect<O, never, InvocationServices> =>
-          Effect.gen(function* () {
-            if (functionDef.meta?.deployedFunctionId) {
-              return yield* remoteExecutioner.callFunction<I, O>(functionDef.meta.deployedFunctionId, input);
-            }
-
-            return yield* localExecutioner.invokeFunction(functionDef, input);
-          }),
-      } satisfies Context.Tag.Service<FunctionInvocationService>;
-    }),
-  );
-
-  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
-  static layerTest = ({
-    functions = [],
-  }: {
-    functions?: FunctionDefinition<any, any>[];
-  } = {}): Layer.Layer<
-    FunctionInvocationService,
-    never,
-    AiService.AiService | CredentialsService | DatabaseService | QueueService
-  > =>
-    FunctionInvocationService.layer.pipe(
-      Layer.provide(LocalFunctionExecutionService.layerLive),
-      Layer.provide(FunctionImplementationResolver.layerTest({ functions })),
-      Layer.provide(RemoteFunctionExecutionService.layerMock),
-    );
-
-  // TODO(dmaretskyi): This shouldn't default to all services being not available.
-  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
-  /**
-   * @deprecated Use {@link layerTest} instead.
-   */
-  static layerTestMocked = ({
-    functions,
-  }: {
-    functions: FunctionDefinition<any, any>[];
-  }): Layer.Layer<FunctionInvocationService> =>
-    FunctionInvocationService.layerTest({ functions }).pipe(
-      Layer.provide(AiService.notAvailable),
-      Layer.provide(CredentialsService.configuredLayer([])),
-      Layer.provide(DatabaseService.notAvailable),
-      Layer.provide(QueueService.notAvailable),
-    );
+  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>,
+    input: I,
+  ): Effect.Effect<O, never, FunctionInvocationService | InvocationServices> =>
+    Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+
+  static resolveFunction = (
+    key: string,
+  ): Effect.Effect<FunctionDefinition.Any, FunctionNotFoundError, FunctionInvocationService> =>
+    Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.resolveFunction)(key);
 }

package/src/services/index.ts

@@ -3,11 +3,9 @@
 //
 
 export * from './credentials';
-export * from './database';
+export { ConfiguredCredentialsService, type ServiceCredential } from './credentials';
 export * from './event-logger';
+export { createEventLogger, createDefectLogger } from './event-logger';
 export * from './function-invocation-service';
-export * from './local-function-execution';
 export * from './queues';
-export * from './service-container';
 export * from './tracing';
-export * from './remote-function-execution-service';

package/src/services/queues.ts

@@ -6,7 +6,7 @@ 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 { Entity } from '@dxos/echo';
 import type { Queue, QueueAPI, QueueFactory } from '@dxos/echo-db';
 import type { DXN, QueueSubspaceTag } from '@dxos/keys';
 
@@ -53,22 +53,20 @@ 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));
 }
 
 /**

package/src/services/tracing.ts

@@ -7,11 +7,11 @@ 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 { Queue } from '@dxos/echo-db';
-import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { type DXN, Obj } 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)
@@ -29,31 +29,34 @@ 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;
+
+    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> = { write: () => {}, getTraceContext: () => ({}) };
-
-  static layerNoop = Layer.succeed(TracingService, TracingService.noop);
-
-  static console: Context.Tag.Service<TracingService> = {
-    write: (event) => {
-      console.log(event);
-    },
+  static noop: Context.Tag.Service<TracingService> = {
     getTraceContext: () => ({}),
+    write: () => {},
+    traceInvocationStart: () =>
+      Effect.sync(() => ({ invocationId: ObjectId.random(), invocationTraceQueue: undefined })),
+    traceInvocationEnd: () => Effect.sync(() => {}),
   };
 
-  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: () => ({}),
-    });
+  static layerNoop: Layer.Layer<TracingService> = Layer.succeed(TracingService, TracingService.noop);
 
   /**
    * Creates a TracingService layer that emits events to the parent tracing service.
@@ -65,27 +68,24 @@ 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),
           getTraceContext: () => context,
+          traceInvocationStart: () => Effect.die('Tracing invocation inside another invocation is not supported.'),
+          traceInvocationEnd: () => Effect.die('Tracing invocation inside another invocation is not supported.'),
         };
       }),
     );
 
-  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(),
-            },
-          }),
-        };
-      }),
-    );
+  /**
+   * 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.
@@ -101,15 +101,16 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
         created: new Date().toISOString(),
         ...data,
       }),
+      tracing.getTraceContext(),
     );
   });
 
   static emitConverationMessage: (
-    data: Obj.MakeProps<typeof DataType.Message>,
+    data: Obj.MakeProps<typeof Message.Message>,
   ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
     const tracing = yield* TracingService;
     tracing.write(
-      Obj.make(DataType.Message, {
+      Obj.make(Message.Message, {
         parentMessage: tracing.getTraceContext().parentMessage,
         ...data,
         properties: {
@@ -117,12 +118,15 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
           ...data.properties,
         },
       }),
+      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.
      */
@@ -135,9 +139,29 @@ 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;
+    };
+  }
 }
 
 /**
- * Goes into {@link DataType.Message['properties']}
+ * Goes into {@link Message['properties']}
  */
 export const MESSAGE_PROPERTY_TOOL_CALL_ID = 'toolCallId' as const;

package/src/types/Function.ts

@@ -0,0 +1,82 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Annotation, JsonSchema, Obj, Type } from '@dxos/echo';
+import { SystemTypeAnnotation } from '@dxos/echo/internal';
+
+import { Script } from './Script';
+
+/**
+ * Function deployment.
+ */
+export const Function = Schema.Struct({
+  /**
+   * Global registry ID.
+   * NOTE: The `key` property refers to the original registry entry.
+   */
+  // TODO(burdon): Create Format type for DXN-like ids, such as this and schema type.
+  // TODO(dmaretskyi): Consider making it part of ECHO meta.
+  // TODO(dmaretskyi): Make required.
+  key: Schema.optional(Schema.String).annotations({
+    description: 'Unique registration key for the blueprint',
+  }),
+
+  name: Schema.NonEmptyString,
+  version: Schema.String,
+
+  description: Schema.optional(Schema.String),
+
+  /**
+   * ISO date string of the last deployment.
+   */
+  updated: Schema.optional(Schema.String),
+
+  // Reference to a source script if it exists within ECHO.
+  // TODO(burdon): Don't ref ScriptType directly (core).
+  source: Schema.optional(Type.Ref(Script)),
+
+  inputSchema: Schema.optional(JsonSchema.JsonSchema),
+  outputSchema: Schema.optional(JsonSchema.JsonSchema),
+
+  /**
+   * List of required services.
+   * Match the Context.Tag keys of the FunctionServices variants.
+   */
+  services: Schema.optional(Schema.Array(Schema.String)),
+
+  // Local binding to a function name.
+  binding: Schema.optional(Schema.String),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Function',
+    version: '0.1.0',
+  }),
+  Annotation.LabelAnnotation.set(['name']),
+  SystemTypeAnnotation.set(true),
+);
+
+export interface Function extends Schema.Schema.Type<typeof Function> {}
+
+export const make = (props: Obj.MakeProps<typeof Function>) => Obj.make(Function, props);
+
+/**
+ * Copies properties from source to target.
+ * @param target - Target object to copy properties to.
+ * @param source - Source object to copy properties from.
+ */
+export const setFrom = (target: Function, source: Function) => {
+  Obj.change(target, (t) => {
+    t.key = source.key ?? target.key;
+    t.name = source.name ?? target.name;
+    t.version = source.version;
+    t.description = source.description;
+    t.updated = source.updated;
+    // TODO(dmaretskyi): A workaround for an ECHO bug.
+    t.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : undefined;
+    t.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : undefined;
+    Obj.getMeta(t).keys = JSON.parse(JSON.stringify(Obj.getMeta(source).keys));
+  });
+};

package/src/types/Script.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Annotation, Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation } from '@dxos/echo/internal';
+import { Text } from '@dxos/schema';
+
+/**
+ * Source script.
+ */
+export const Script = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  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(FormInputAnnotation.set(false), Schema.optional),
+  source: Type.Ref(Text.Text).pipe(FormInputAnnotation.set(false)),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Script',
+    version: '0.1.0',
+  }),
+  Annotation.LabelAnnotation.set(['name']),
+);
+
+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 = {}): Script =>
+  Obj.make(Script, { ...props, source: Ref.make(Text.make(source)) });

package/src/types/Trigger.ts

@@ -0,0 +1,143 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { Obj, QueryAST, Type } from '@dxos/echo';
+import { OptionsAnnotationId, SystemTypeAnnotation } from '@dxos/echo/internal';
+import { DXN } from '@dxos/keys';
+import { Expando } from '@dxos/schema';
+
+/**
+ * Type discriminator for TriggerType.
+ * Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.
+ * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
+ */
+export const Kinds = ['email', 'queue', 'subscription', 'timer', 'webhook'] as const;
+export type Kind = (typeof Kinds)[number];
+
+const kindLiteralAnnotations = { title: 'Kind' };
+
+export const EmailSpec = Schema.Struct({
+  kind: Schema.Literal('email').annotations(kindLiteralAnnotations),
+});
+export type EmailSpec = Schema.Schema.Type<typeof EmailSpec>;
+
+export const QueueSpec = Schema.Struct({
+  kind: Schema.Literal('queue').annotations(kindLiteralAnnotations),
+
+  // TODO(dmaretskyi): Change to a reference.
+  queue: DXN.Schema,
+});
+export type QueueSpec = Schema.Schema.Type<typeof QueueSpec>;
+
+/**
+ * Subscription.
+ */
+export const SubscriptionSpec = Schema.Struct({
+  kind: Schema.Literal('subscription').annotations(kindLiteralAnnotations),
+  query: Schema.Struct({
+    raw: Schema.optional(Schema.String.annotations({ title: 'Query' })),
+    ast: QueryAST.Query,
+  }),
+  options: Schema.optional(
+    Schema.Struct({
+      // Watch changes to object (not just creation).
+      deep: Schema.optional(Schema.Boolean.annotations({ title: 'Nested' })),
+      // Debounce changes (delay in ms).
+      delay: Schema.optional(Schema.Number.annotations({ title: 'Delay' })),
+    }).annotations({ title: 'Options' }),
+  ),
+});
+export type SubscriptionSpec = Schema.Schema.Type<typeof SubscriptionSpec>;
+
+/**
+ * Cron timer.
+ */
+export const TimerSpec = Schema.Struct({
+  kind: Schema.Literal('timer').annotations(kindLiteralAnnotations),
+  cron: Schema.String.annotations({
+    title: 'Cron',
+    [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
+  }),
+});
+export type TimerSpec = Schema.Schema.Type<typeof TimerSpec>;
+
+/**
+ * Webhook.
+ */
+export const WebhookSpec = Schema.Struct({
+  kind: Schema.Literal('webhook').annotations(kindLiteralAnnotations),
+  method: Schema.optional(
+    Schema.String.annotations({
+      title: 'Method',
+      [OptionsAnnotationId]: ['GET', 'POST'],
+    }),
+  ),
+  port: Schema.optional(
+    Schema.Number.annotations({
+      title: 'Port',
+    }),
+  ),
+});
+export type WebhookSpec = Schema.Schema.Type<typeof WebhookSpec>;
+
+/**
+ * Trigger schema.
+ */
+export const Spec = Schema.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
+  title: 'Trigger',
+});
+export type Spec = Schema.Schema.Type<typeof Spec>;
+
+/**
+ * Function trigger.
+ * Function is invoked with the `payload` passed as input data.
+ * The event that triggers the function is available in the function context.
+ */
+const TriggerSchema = Schema.Struct({
+  /**
+   * Function or workflow to invoke.
+   */
+  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
+  function: Schema.optional(Type.Ref(Expando.Expando).annotations({ title: 'Function' })),
+
+  /**
+   * Only used for workflowSchema.
+   * Specifies the input node in the circuit.
+   * @deprecated Remove and enforce a single input node in all compute graphSchema.
+   */
+  inputNodeId: Schema.optional(Schema.String.annotations({ title: 'Input Node ID' })),
+
+  // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
+  //  Need lint rule; or agent rule to require PR review for "boolean" key word.
+  enabled: Schema.optional(Schema.Boolean.annotations({ title: 'Enabled' })),
+
+  spec: Schema.optional(Spec),
+
+  /**
+   * Passed as the input data to the function.
+   * Must match the function's input schema.
+   *
+   * @example
+   * {
+   *   item: '{{$.trigger.event}}',
+   *   instructions: 'Summarize and perform entity-extraction'
+   *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
+   * }
+   */
+  input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Trigger',
+    version: '0.1.0',
+  }),
+  SystemTypeAnnotation.set(true),
+);
+
+export interface Trigger extends Schema.Schema.Type<typeof TriggerSchema> {}
+export const Trigger: Type.Obj<Trigger> = TriggerSchema as any;
+
+export const make = (props: Obj.MakeProps<typeof Trigger>) => Obj.make(Trigger, props);

package/src/types/TriggerEvent.ts

@@ -0,0 +1,62 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { DXN, Type } from '@dxos/echo';
+
+// TODO(wittjosiah): Review this type.
+//   - Should be discriminated union.
+//   - Should be more consistent (e.g. subject vs item).
+//   - Should re-use schemas if possible.
+
+// TODO(burdon): Reuse trigger schema from @dxos/functions (TriggerType).
+export const EmailEvent = Schema.Struct({
+  from: Schema.String,
+  to: Schema.String,
+  subject: Schema.String,
+  created: Schema.String,
+  body: Schema.String,
+});
+export type EmailEvent = Schema.Schema.Type<typeof EmailEvent>;
+
+export const QueueEvent = Schema.Struct({
+  queue: DXN.Schema,
+  item: Schema.Any,
+  cursor: Schema.String,
+});
+export type QueueEvent = Schema.Schema.Type<typeof QueueEvent>;
+
+export const SubscriptionEvent = Schema.Struct({
+  /**
+   * Type of the mutation.
+   */
+  // TODO(dmaretskyi): Specify enum.
+  type: Schema.String,
+
+  /**
+   * Reference to the object that was changed or created.
+   */
+  subject: Type.Ref(Type.Obj),
+
+  /**
+   * @deprecated
+   */
+  changedObjectId: Schema.optional(Schema.String),
+});
+export type SubscriptionEvent = Schema.Schema.Type<typeof SubscriptionEvent>;
+
+export const TimerEvent = Schema.Struct({ tick: Schema.Number });
+export type TimerEvent = Schema.Schema.Type<typeof TimerEvent>;
+
+export const WebhookEvent = Schema.Struct({
+  url: Schema.String,
+  method: Schema.Literal('GET', 'POST'),
+  headers: Schema.Record({ key: Schema.String, value: Schema.String }),
+  bodyText: Schema.String,
+});
+export type WebhookEvent = Schema.Schema.Type<typeof WebhookEvent>;
+
+export const TriggerEvent = Schema.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
+export type TriggerEvent = Schema.Schema.Type<typeof TriggerEvent>;

package/src/types/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * as Function from './Function';
+export * as Script from './Script';
+export * as Trigger from './Trigger';
+export * as TriggerEvent from './TriggerEvent';
+export * from './url';