@dxos/functions 0.8.4-main.a4bbb77 → 0.8.4-main.ae835ea

package/src/testing/layer.ts

@@ -2,13 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { Schema } from 'effect';
-import { Context, Effect, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import type * as Schema from 'effect/Schema';
 
 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 { acquireReleaseResource } from '@dxos/effect';
 import { PublicKey } from '@dxos/keys';
 import type { LevelDB } from '@dxos/kv-store';
 import { createTestLevel } from '@dxos/kv-store/testing';
@@ -16,7 +18,7 @@ import { log } from '@dxos/log';
 
 import { DatabaseService, QueueService } from '../services';
 
-const testBuilder = accuireReleaseResource(() => new EchoTestBuilder());
+const testBuilder = acquireReleaseResource(() => new EchoTestBuilder());
 
 export const testStoragePath = ({ name = PublicKey.random().toHex() }: { name?: string }) => {
   return `/tmp/dxos-${name}`;

package/src/testing/logger.ts

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

package/src/testing/persist-database.test.ts

@@ -3,7 +3,7 @@
 //
 
 import { describe, expect, it } from '@effect/vitest';
-import { Effect } from 'effect';
+import * as Effect from 'effect/Effect';
 
 import { Filter, Obj, Query, Type } from '@dxos/echo';
 import { DataType } from '@dxos/schema';

package/src/testing/services.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Context } from 'effect';
+import type * as Context from 'effect/Context';
 
 import type { Space } from '@dxos/client/echo';
 import type { EchoDatabase, QueueFactory } from '@dxos/echo-db';

package/src/trace.ts

@@ -2,14 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { type Ref, Type } from '@dxos/echo';
+import { ObjectId } from '@dxos/echo/internal';
 import { Queue } from '@dxos/echo-db';
-import { ObjectId } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
-import { FunctionTrigger } from './types';
+import { Trigger } from './types';
 
 export enum InvocationOutcome {
   SUCCESS = 'success',
@@ -61,7 +61,7 @@ export const InvocationTraceStartEvent = Schema.Struct({
   /**
    * Present for automatic invocations.
    */
-  trigger: Schema.optional(Type.Ref(FunctionTrigger)),
+  trigger: Schema.optional(Type.Ref(Trigger.Trigger)),
 }).pipe(Type.Obj({ typename: 'dxos.org/type/InvocationTraceStart', version: '0.1.0' }));
 
 export type InvocationTraceStartEvent = Schema.Schema.Type<typeof InvocationTraceStartEvent>;
@@ -121,7 +121,7 @@ export type InvocationSpan = {
   input: object;
   invocationTraceQueue?: Ref.Ref<Queue>;
   invocationTarget?: Ref.Ref<Type.Expando>;
-  trigger?: Ref.Ref<FunctionTrigger>;
+  trigger?: Ref.Ref<Trigger.Trigger>;
   exception?: TraceEventException;
 };
 

package/src/translations.ts

@@ -4,12 +4,12 @@
 
 import { type Resource } from 'i18next';
 
-import { ScriptType } from './schema';
+import { Script } from './types';
 
 export const translations = [
   {
     'en-US': {
-      [ScriptType.typename]: {
+      [Script.Script.typename]: {
         'typename label': 'Script',
         'typename label_zero': 'Scripts',
         'typename label_one': 'Script',

package/src/triggers/input-builder.ts

@@ -2,9 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type EventType, type FunctionTrigger } from '@dxos/functions';
+import { type Trigger, type TriggerEvent } from '../types';
 
-export const createInvocationPayload = (trigger: FunctionTrigger, event: EventType): any => {
+export const createInvocationPayload = (trigger: Trigger.Trigger, event: TriggerEvent.TriggerEvent): any => {
   if (!trigger.input) {
     return event;
   }

package/src/triggers/invocation-tracer.ts

@@ -2,7 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer } from 'effect';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
 
 import { Obj, Ref } from '@dxos/echo';
 import { type Queue } from '@dxos/echo-db';
@@ -15,14 +17,14 @@ import {
   InvocationTraceEventType,
   InvocationTraceStartEvent,
 } from '../trace';
-import type { TriggerKind } from '../types';
+import type { Trigger } from '../types';
 
 export type FunctionInvocationPayload = {
   data?: any;
   inputNodeId?: string;
   trigger?: {
     id: string;
-    kind: TriggerKind;
+    kind: Trigger.Kind;
   };
 };
 

package/src/triggers/trigger-dispatcher.test.ts

@@ -2,18 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-import { FetchHttpClient } from '@effect/platform';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
 import { describe, it } from '@effect/vitest';
-import { Duration, Effect, Exit, Layer, pipe } from 'effect';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
+import * as Fn from 'effect/Function';
+import * as Layer from 'effect/Layer';
 
 import { AiService } from '@dxos/ai';
 import { Filter, Obj, Query, Ref } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { DataType } from '@dxos/schema';
 
-import { default as reply } from '../examples/reply';
+import { Example } from '../example';
 import { serializeFunction } from '../handler';
-import { FunctionType } from '../schema';
 import {
   ComputeEventLogger,
   CredentialsService,
@@ -23,25 +26,25 @@ import {
   TracingService,
 } from '../services';
 import { TestDatabaseLayer } from '../testing';
-import { FunctionTrigger } from '../types';
+import { Function, Trigger } from '../types';
 
 import { InvocationTracer } from './invocation-tracer';
 import { TriggerDispatcher } from './trigger-dispatcher';
 import { TriggerStateStore } from './trigger-state-store';
 
-const TestLayer = pipe(
+const TestLayer = Fn.pipe(
   Layer.mergeAll(ComputeEventLogger.layerFromTracing, InvocationTracer.layerTest, TriggerStateStore.layerMemory),
   Layer.provideMerge(
     Layer.mergeAll(
       AiService.notAvailable,
       CredentialsService.layerConfig([]),
-      FunctionInvocationService.layerTestMocked({ functions: [reply] }).pipe(
+      FunctionInvocationService.layerTestMocked({ functions: [Example.reply] }).pipe(
         Layer.provideMerge(ComputeEventLogger.layerFromTracing),
         Layer.provideMerge(TracingService.layerLogInfo()),
       ),
       FetchHttpClient.layer,
       TestDatabaseLayer({
-        types: [FunctionType, FunctionTrigger, DataType.Person, DataType.Task],
+        types: [Function.Function, Trigger.Trigger, DataType.Person, DataType.Task],
       }),
     ),
   ),
@@ -76,9 +79,9 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should manually invoke trigger',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -102,9 +105,9 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should invoke scheduled timer triggers',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -131,10 +134,10 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should handle disabled triggers',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
-        const enabledTrigger = Obj.make(FunctionTrigger, {
+        const enabledTrigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -143,7 +146,7 @@ describe('TriggerDispatcher', () => {
           },
         });
 
-        const disabledTrigger = Obj.make(FunctionTrigger, {
+        const disabledTrigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: false,
           spec: {
@@ -172,11 +175,11 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'cron triggers are invoked periodically on schedule',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
         // cron every 5 minutes
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -223,9 +226,9 @@ describe('TriggerDispatcher', () => {
         // Initially no triggers in database
 
         // Add a trigger dynamically
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -246,7 +249,7 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should support Effect cron expressions',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
         const validPatterns = [
@@ -261,7 +264,7 @@ describe('TriggerDispatcher', () => {
 
         // Test that valid patterns can be invoked
         for (const cron of validPatterns) {
-          const trigger = Obj.make(FunctionTrigger, {
+          const trigger = Trigger.make({
             function: Ref.make(functionObj),
             enabled: true,
             spec: {
@@ -280,11 +283,11 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should handle invalid cron expressions gracefully',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
         // Test with an invalid pattern
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -323,9 +326,9 @@ describe('TriggerDispatcher', () => {
       'should invoke scheduled queue triggers',
       Effect.fnUntraced(function* ({ expect }) {
         const queue = yield* QueueService.createQueue();
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -352,9 +355,9 @@ describe('TriggerDispatcher', () => {
       'triggers are invoked one by one',
       Effect.fnUntraced(function* ({ expect }) {
         const queue = yield* QueueService.createQueue();
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -399,9 +402,9 @@ describe('TriggerDispatcher', () => {
       'builds input from pattern',
       Effect.fnUntraced(function* ({ expect }) {
         const queue = yield* QueueService.createQueue();
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
@@ -442,16 +445,18 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should invoke triggers on object creation',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
         // Create a subscription trigger that watches for DataType.Person objects
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Person)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Person)).ast,
+            },
           },
         });
         yield* DatabaseService.add(trigger);
@@ -478,7 +483,7 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should invoke triggers on object updates',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
         // Create a person object first
@@ -488,12 +493,14 @@ describe('TriggerDispatcher', () => {
         yield* DatabaseService.add(person);
 
         // Create a subscription trigger
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Person)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Person)).ast,
+            },
           },
         });
         yield* DatabaseService.add(trigger);
@@ -520,16 +527,18 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should not invoke triggers for unchanged objects',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
         // Create a subscription trigger first
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Person)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Person)).ast,
+            },
           },
         });
         yield* DatabaseService.add(trigger);
@@ -568,16 +577,18 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should handle multiple object types with filters',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
         // Create a subscription trigger that only watches for DataType.Task objects
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Task)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Task)).ast,
+            },
           },
         });
         yield* DatabaseService.add(trigger);
@@ -610,7 +621,7 @@ describe('TriggerDispatcher', () => {
     it.effect(
       'should pass correct event data to function',
       Effect.fnUntraced(function* ({ expect }) {
-        const functionObj = serializeFunction(reply);
+        const functionObj = serializeFunction(Example.reply);
         yield* DatabaseService.add(functionObj);
 
         const person = Obj.make(DataType.Person, {
@@ -619,12 +630,14 @@ describe('TriggerDispatcher', () => {
         yield* DatabaseService.add(person);
 
         // Create a subscription trigger with input pattern
-        const trigger = Obj.make(FunctionTrigger, {
+        const trigger = Trigger.make({
           function: Ref.make(functionObj),
           enabled: true,
           spec: {
             kind: 'subscription',
-            query: Query.select(Filter.type(DataType.Person)).ast,
+            query: {
+              ast: Query.select(Filter.type(DataType.Person)).ast,
+            },
           },
           input: {
             objectId: '{{event.changedObjectId}}',

package/src/triggers/trigger-dispatcher.ts

@@ -2,7 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Cause, Context, Cron, Duration, Effect, Either, Exit, Fiber, Layer, Option, Record, Schedule } from 'effect';
+import * as Cause from 'effect/Cause';
+import * as Context from 'effect/Context';
+import * as Cron from 'effect/Cron';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Either from 'effect/Either';
+import * as Exit from 'effect/Exit';
+import * as Fiber from 'effect/Fiber';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
+import * as Schedule from 'effect/Schedule';
 
 import { DXN, Filter, Obj, Query } from '@dxos/echo';
 import { causeToError } from '@dxos/effect';
@@ -11,7 +22,6 @@ import { log } from '@dxos/log';
 import { KEY_QUEUE_POSITION } from '@dxos/protocols';
 
 import { deserializeFunction } from '../handler';
-import { FunctionType } from '../schema';
 import {
   ComputeEventLogger,
   DatabaseService,
@@ -19,15 +29,7 @@ import {
   QueueService,
   TracingService,
 } from '../services';
-import {
-  type EventType,
-  FunctionTrigger,
-  type QueueTriggerOutput,
-  type SubscriptionTriggerOutput,
-  type TimerTrigger,
-  type TimerTriggerOutput,
-  type TriggerKind,
-} from '../types';
+import { Function, Trigger, type TriggerEvent } from '../types';
 
 import { createInvocationPayload } from './input-builder';
 import { InvocationTracer } from './invocation-tracer';
@@ -57,8 +59,8 @@ export interface TriggerDispatcherOptions {
 }
 
 export interface InvokeTriggerOptions {
-  trigger: FunctionTrigger;
-  event: EventType;
+  trigger: Trigger.Trigger;
+  event: TriggerEvent.TriggerEvent;
 }
 export interface TriggerExecutionResult {
   triggerId: string;
@@ -69,7 +71,7 @@ export interface TriggerExecutionResult {
  * Cront trigger runtime state.
  */
 interface ScheduledTrigger {
-  trigger: FunctionTrigger;
+  trigger: Trigger.Trigger;
   cron: Cron.Cron;
   nextExecution: Date;
 }
@@ -117,7 +119,7 @@ export class TriggerDispatcher extends Context.Tag('@dxos/functions/TriggerDispa
      * Invoke all scheduled triggers who are due.
      */
     invokeScheduledTriggers(opts?: {
-      kinds?: TriggerKind[];
+      kinds?: Trigger.Kind[];
     }): Effect.Effect<TriggerExecutionResult[], never, TriggerDispatcherServices>;
 
     /**
@@ -238,7 +240,7 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
 
         // Resolve the function
         const serialiedFunction = yield* DatabaseService.load(trigger.function!).pipe(Effect.orDie);
-        invariant(Obj.instanceOf(FunctionType, serialiedFunction));
+        invariant(Obj.instanceOf(Function.Function, serialiedFunction));
         const functionDef = deserializeFunction(serialiedFunction);
 
         // Prepare input data
@@ -288,7 +290,7 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
             {
               yield* this.refreshTriggers();
               const now = this.getCurrentTime();
-              const triggersToInvoke: FunctionTrigger[] = [];
+              const triggersToInvoke: Trigger.Trigger[] = [];
 
               for (const [triggerId, scheduledTrigger] of this._scheduledTriggers.entries()) {
                 if (scheduledTrigger.nextExecution <= now) {
@@ -306,7 +308,7 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
                   (trigger) =>
                     this.invokeTrigger({
                       trigger,
-                      event: { tick: now.getTime() } satisfies TimerTriggerOutput,
+                      event: { tick: now.getTime() } satisfies TriggerEvent.TimerEvent,
                     }),
                   { concurrency: 1 },
                 )),
@@ -339,7 +341,7 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
                       queue: spec.queue,
                       item: object,
                       cursor: objectPos,
-                    } satisfies QueueTriggerOutput,
+                    } satisfies TriggerEvent.QueueEvent,
                   }),
                 );
 
@@ -362,7 +364,7 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
                 continue;
               }
 
-              const { objects } = yield* DatabaseService.runQuery(Query.fromAst(spec.query));
+              const { objects } = yield* DatabaseService.runQuery(Query.fromAst(spec.query.ast));
 
               const state: TriggerState = yield* TriggerStateStore.getState(trigger.id).pipe(
                 Effect.catchTag('TRIGGER_STATE_NOT_FOUND', () =>
@@ -403,7 +405,7 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
                       subject: db.ref(Obj.getDXN(object)),
 
                       changedObjectId: object.id,
-                    } satisfies SubscriptionTriggerOutput,
+                    } satisfies TriggerEvent.SubscriptionEvent,
                   }),
                 );
                 (state.state.processedVersions as any)[object.id] = Obj.encodeVersion(currentVersion);
@@ -462,7 +464,7 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
       // Add or update triggers
       for (const trigger of triggers) {
         if (trigger.spec?.kind === 'timer' && trigger.enabled) {
-          const timerSpec = trigger.spec as TimerTrigger;
+          const timerSpec = trigger.spec as Trigger.TimerSpec;
 
           // Parse cron expression using Effect's Cron module
           const cronEither = Cron.parse(timerSpec.cron);
@@ -499,7 +501,7 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
 
   private _fetchTriggers = () =>
     Effect.gen(this, function* () {
-      const { objects } = yield* DatabaseService.runQuery(Filter.type(FunctionTrigger));
+      const { objects } = yield* DatabaseService.runQuery(Filter.type(Trigger.Trigger));
       return objects;
     }).pipe(Effect.withSpan('TriggerDispatcher.fetchTriggers'));
 
@@ -508,14 +510,11 @@ class TriggerDispatcherImpl implements Context.Tag.Service<TriggerDispatcher> {
       yield* this.invokeScheduledTriggers();
     }).pipe(Effect.repeat(Schedule.fixed(this.livePollInterval)), Effect.asVoid);
 
-  private _prepareInputData = (trigger: FunctionTrigger, event: EventType): any => {
+  private _prepareInputData = (trigger: Trigger.Trigger, event: TriggerEvent.TriggerEvent): any => {
     return createInvocationPayload(trigger, event);
   };
 }
 
-// Re-exports
-export { FunctionTrigger, type TimerTrigger } from '../types';
-
 /**
  * Key for the current queue cursor for queue triggers.
  */

package/src/triggers/trigger-state-store.ts

@@ -2,11 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
-import { KeyValueStore } from '@effect/platform';
-import { Context } from 'effect';
-import { Schema } from 'effect';
-import { Effect, Layer } from 'effect';
-import { Option } from 'effect';
+import * as KeyValueStore from '@effect/platform/KeyValueStore';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
 
 import { ObjectId } from '@dxos/keys';