@dxos/functions 0.8.4-main.c85a9c8dae → 0.8.4-main.cb12b3f963

package/src/services/credentials.ts

@@ -10,136 +10,24 @@ import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 import * as Redacted from 'effect/Redacted';
 
+import { Credential } from '@dxos/compute';
 import { Query } from '@dxos/echo';
 import { Database } from '@dxos/echo';
 import { AccessToken } from '@dxos/types';
 
-export type CredentialQuery = {
-  service?: string;
-};
-
-// TODO(dmaretskyi): Unify with other apis.
-// packages/sdk/schema/src/common/access-token.ts
-export type ServiceCredential = {
-  service: string;
-
-  // TODO(dmaretskyi): Build out.
-  apiKey?: string;
-};
-
-export class CredentialsService extends Context.Tag('@dxos/functions/CredentialsService')<
-  CredentialsService,
-  {
-    /**
-     * Query all.
-     */
-    queryCredentials: (query: CredentialQuery) => Promise<ServiceCredential[]>;
-
-    /**
-     * Get a single credential.
-     * @throws {Error} If no credential is found.
-     */
-    getCredential: (query: CredentialQuery) => Promise<ServiceCredential>;
-  }
->() {
-  static getCredential = (query: CredentialQuery): Effect.Effect<ServiceCredential, never, CredentialsService> =>
-    Effect.gen(function* () {
-      const credentials = yield* CredentialsService;
-      return yield* Effect.promise(() => credentials.getCredential(query));
-    });
-
-  static getApiKey = (query: CredentialQuery): Effect.Effect<Redacted.Redacted<string>, never, CredentialsService> =>
-    Effect.gen(function* () {
-      const credential = yield* CredentialsService.getCredential(query);
-      if (!credential.apiKey) {
-        throw new Error(`API key not found for service: ${query.service}`);
-      }
-      return Redacted.make(credential.apiKey);
-    });
-
-  static configuredLayer = (credentials: ServiceCredential[]) =>
-    Layer.succeed(CredentialsService, new ConfiguredCredentialsService(credentials));
-
-  static layerConfig = (
-    credentials: {
-      service: string;
-      apiKey: Config.Config<Redacted.Redacted<string>>;
-    }[],
-  ) =>
-    Layer.effect(
-      CredentialsService,
-      Effect.gen(function* () {
-        const serviceCredentials = yield* Effect.forEach(credentials, ({ service, apiKey }) =>
-          Effect.gen(function* () {
-            return {
-              service,
-              apiKey: Redacted.value(yield* apiKey),
-            };
-          }),
-        );
-
-        return new ConfiguredCredentialsService(serviceCredentials);
-      }),
-    );
-
-  static layerFromDatabase = ({ caching = false }: { caching?: boolean } = {}) =>
-    Layer.effect(
-      CredentialsService,
-      Effect.gen(function* () {
-        const dbService = yield* Database.Service;
-        const cache = new Map<string, ServiceCredential[]>();
-
-        const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
-          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);
-          }
+export class ConfiguredCredentialsService implements Context.Tag.Service<Credential.CredentialsService> {
+  constructor(private readonly credentials: Credential.ServiceCredential[] = []) {}
 
-          return credentials;
-        };
-
-        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> {
-  constructor(private readonly credentials: ServiceCredential[] = []) {}
-
-  addCredentials(credentials: ServiceCredential[]): ConfiguredCredentialsService {
+  addCredentials(credentials: Credential.ServiceCredential[]): ConfiguredCredentialsService {
     this.credentials.push(...credentials);
     return this;
   }
 
-  async queryCredentials(query: CredentialQuery): Promise<ServiceCredential[]> {
+  async queryCredentials(query: Credential.CredentialQuery): Promise<Credential.ServiceCredential[]> {
     return this.credentials.filter((credential) => credential.service === query.service);
   }
 
-  async getCredential(query: CredentialQuery): Promise<ServiceCredential> {
+  async getCredential(query: Credential.CredentialQuery): Promise<Credential.ServiceCredential> {
     const credential = this.credentials.find((credential) => credential.service === query.service);
     if (!credential) {
       throw new Error(`Credential not found for service: ${query.service}`);
@@ -157,3 +45,72 @@ export const withAuthorization = (token: string, kind?: 'Bearer' | 'Basic') =>
     const authorization = kind ? `${kind} ${token}` : token;
     return HttpClientRequest.setHeader(request, 'Authorization', authorization);
   });
+
+export const configuredCredentialsLayer = (credentials: Credential.ServiceCredential[]) =>
+  Layer.succeed(Credential.CredentialsService, new ConfiguredCredentialsService(credentials));
+
+export const credentialsLayerConfig = (
+  credentials: {
+    service: string;
+    apiKey: Config.Config<Redacted.Redacted<string>>;
+  }[],
+) =>
+  Layer.effect(
+    Credential.CredentialsService,
+    Effect.gen(function* () {
+      const serviceCredentials = yield* Effect.forEach(credentials, ({ service, apiKey }) =>
+        Effect.gen(function* () {
+          return {
+            service,
+            apiKey: Redacted.value(yield* apiKey),
+          };
+        }),
+      );
+
+      return new ConfiguredCredentialsService(serviceCredentials);
+    }),
+  );
+
+export const credentialsLayerFromDatabase = ({ caching = false }: { caching?: boolean } = {}) =>
+  Layer.effect(
+    Credential.CredentialsService,
+    Effect.gen(function* () {
+      const dbService = yield* Database.Service;
+      const cache = new Map<string, Credential.ServiceCredential[]>();
+
+      const queryCredentials = async (query: Credential.CredentialQuery): Promise<Credential.ServiceCredential[]> => {
+        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);
+          if (credentials.length === 0) {
+            throw new Error(`Credential not found for service: ${query.service}`);
+          }
+
+          return credentials[0];
+        },
+        queryCredentials: async (query) => {
+          return queryCredentials(query);
+        },
+      };
+    }),
+  );

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

@@ -5,18 +5,14 @@ import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
-import type { FunctionNotFoundError } from '../errors';
-import { type FunctionDefinition, type InvocationServices } from '../sdk';
+import { type FunctionNotFoundError, Operation } from '@dxos/compute';
 
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
   FunctionInvocationService,
   {
-    invokeFunction<I, O>(
-      functionDef: FunctionDefinition<I, O, any>,
-      input: I,
-    ): Effect.Effect<O, never, InvocationServices>;
+    invokeFunction<I, O>(functionDef: Operation.Definition<I, O, any>, input: I): Effect.Effect<O>;
 
-    resolveFunction(key: string): Effect.Effect<FunctionDefinition.Any, FunctionNotFoundError>;
+    resolveFunction(key: string): Effect.Effect<Operation.Definition.Any, FunctionNotFoundError>;
   }
 >() {
   static layerNotAvailable = Layer.succeed(FunctionInvocationService, {
@@ -25,13 +21,13 @@ export class FunctionInvocationService extends Context.Tag('@dxos/functions/Func
   });
 
   static invokeFunction = <I, O>(
-    functionDef: FunctionDefinition<I, O, any>,
+    functionDef: Operation.Definition<I, O, any>,
     input: I,
-  ): Effect.Effect<O, never, FunctionInvocationService | InvocationServices> =>
+  ): Effect.Effect<O, never, FunctionInvocationService> =>
     Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
 
   static resolveFunction = (
     key: string,
-  ): Effect.Effect<FunctionDefinition.Any, FunctionNotFoundError, FunctionInvocationService> =>
+  ): Effect.Effect<Operation.Definition.Any, FunctionNotFoundError, FunctionInvocationService> =>
     Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.resolveFunction)(key);
 }

package/src/services/index.ts

@@ -3,9 +3,6 @@
 //
 
 export * from './credentials';
-export { ConfiguredCredentialsService, type ServiceCredential } from './credentials';
-export * from './event-logger';
-export { createEventLogger, createDefectLogger } from './event-logger';
 export * from './function-invocation-service';
 export * from './queues';
-export * from './tracing';
+export { MESSAGE_PROPERTY_TOOL_CALL_ID } from './tracing';

package/src/services/queues.ts

@@ -2,81 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-
-import type { Entity } 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('@dxos/functions/QueueService')<
-  QueueService,
-  {
-    /**
-     * API to access the queues.
-     */
-    readonly queues: QueueAPI;
-
-    /**
-     * The queue that is used to store the context of the current research.
-     * @deprecated Use `ContextQueueService` instead.
-     */
-    readonly queue: Queue | undefined;
-  }
->() {
-  static notAvailable = Layer.succeed(QueueService, {
-    queues: {
-      get(_dxn) {
-        throw new Error('Queues not available');
-      },
-      create() {
-        throw new Error('Queues not available');
-      },
-    },
-    queue: undefined,
-  });
-
-  static make = (queues: QueueFactory, queue?: Queue): Context.Tag.Service<QueueService> => {
-    return {
-      queues,
-      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 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 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 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.
- */
-export class ContextQueueService extends Context.Tag('@dxos/functions/ContextQueueService')<
-  ContextQueueService,
-  {
-    readonly queue: Queue;
-  }
->() {
-  static layer = (queue: Queue) => Layer.succeed(ContextQueueService, { queue });
-}
+export { ContextQueueService, QueueService, feedServiceFromQueueServiceLayer } from '@dxos/echo-db';

package/src/services/tracing.ts

@@ -2,165 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Context from 'effect/Context';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-
-import { AgentStatus } from '@dxos/ai';
-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)
- * to emit an execution trace as a series of structured ECHO objects.
- */
-export class TracingService extends Context.Tag('@dxos/functions/TracingService')<
-  TracingService,
-  {
-    /**
-     * Gets the parent message ID.
-     */
-    getTraceContext: () => TracingService.TraceContext;
-
-    /**
-     * Write an event to the tracing queue.
-     * @param event - The event to write. Must be an a typed object.
-     */
-    write: (event: 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: () => {},
-    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.
-   */
-  static layerSubframe = (mapContext: (currentContext: TracingService.TraceContext) => TracingService.TraceContext) =>
-    Layer.effect(
-      TracingService,
-      Effect.gen(function* () {
-        const tracing = yield* TracingService;
-        const context = mapContext(tracing.getTraceContext());
-        return {
-          write: (event, 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.'),
-        };
-      }),
-    );
-
-  /**
-   * 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.
-   */
-  static emitStatus: (
-    data: Omit<Obj.MakeProps<typeof AgentStatus>, 'created'>,
-  ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
-    const tracing = yield* TracingService;
-    tracing.write(
-      Obj.make(AgentStatus, {
-        parentMessage: tracing.getTraceContext().parentMessage,
-        toolCallId: tracing.getTraceContext().toolCallId,
-        created: new Date().toISOString(),
-        ...data,
-      }),
-      tracing.getTraceContext(),
-    );
-  });
-
-  static emitConverationMessage: (
-    data: Obj.MakeProps<typeof Message.Message>,
-  ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
-    const tracing = yield* TracingService;
-    tracing.write(
-      Obj.make(Message.Message, {
-        parentMessage: tracing.getTraceContext().parentMessage,
-        ...data,
-        properties: {
-          [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
-          ...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.
-     */
-    parentMessage?: ObjectId;
-
-    /**
-     * If the current thread is a byproduct of a tool call, this is the ID of the tool call.
-     */
-    toolCallId?: string;
-
-    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 Message['properties']}
  */

package/src/types/index.ts

@@ -2,8 +2,4 @@
 // 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';

package/src/types/url.ts

@@ -5,9 +5,9 @@
 import { type Obj } from '@dxos/echo';
 
 // TODO: use URL scheme for source?
-export const FUNCTIONS_META_KEY = 'dxos.org/service/function';
+export const FUNCTIONS_META_KEY = 'org.dxos.service.function';
 
-export const FUNCTIONS_PRESET_META_KEY = 'dxos.org/service/function-preset';
+export const FUNCTIONS_PRESET_META_KEY = 'org.dxos.service.function-preset';
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
@@ -18,7 +18,7 @@ export const getUserFunctionIdInMetadata = (meta: Obj.ReadonlyMeta) => {
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
- * Must be called inside Obj.changeMeta() since it mutates the meta.
+ * Must be called inside Obj.update() since it mutates the meta.
  */
 export const setUserFunctionIdInMetadata = (meta: Obj.Meta, functionId: string) => {
   const key = meta.keys.find((key) => key.source === FUNCTIONS_META_KEY);

package/dist/types/src/errors.d.ts

@@ -1,121 +0,0 @@
-import { BaseError, type BaseErrorOptions } from '@dxos/errors';
-declare const ServiceNotAvailableError_base: {
-    new (options?: BaseErrorOptions): {
-        name: "ServiceNotAvailable";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "ServiceNotAvailable";
-        stack?: string;
-        cause?: unknown;
-    };
-    name: "ServiceNotAvailable";
-    is(error: unknown): error is BaseError;
-    wrap(options?: Omit<BaseErrorOptions, "cause"> & {
-        ifTypeDiffers?: boolean;
-    }): (error: unknown) => {
-        name: "ServiceNotAvailable";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "ServiceNotAvailable";
-        stack?: string;
-        cause?: unknown;
-    };
-    extend<Name extends string = string>(name: Name, message?: string): any;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-export declare class ServiceNotAvailableError extends ServiceNotAvailableError_base {
-    constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>);
-}
-declare const FunctionNotFoundError_base: {
-    new (options?: BaseErrorOptions): {
-        name: "FunctionNotFound";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "FunctionNotFound";
-        stack?: string;
-        cause?: unknown;
-    };
-    name: "FunctionNotFound";
-    is(error: unknown): error is BaseError;
-    wrap(options?: Omit<BaseErrorOptions, "cause"> & {
-        ifTypeDiffers?: boolean;
-    }): (error: unknown) => {
-        name: "FunctionNotFound";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "FunctionNotFound";
-        stack?: string;
-        cause?: unknown;
-    };
-    extend<Name extends string = string>(name: Name, message?: string): any;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-export declare class FunctionNotFoundError extends FunctionNotFoundError_base {
-    constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>);
-}
-declare const FunctionError_base: {
-    new (options?: BaseErrorOptions): {
-        name: "FunctionError";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "FunctionError";
-        stack?: string;
-        cause?: unknown;
-    };
-    name: "FunctionError";
-    is(error: unknown): error is BaseError;
-    wrap(options?: Omit<BaseErrorOptions, "cause"> & {
-        ifTypeDiffers?: boolean;
-    }): (error: unknown) => {
-        name: "FunctionError";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "FunctionError";
-        stack?: string;
-        cause?: unknown;
-    };
-    extend<Name extends string = string>(name: Name, message?: string): any;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-export declare class FunctionError extends FunctionError_base {
-}
-declare const TriggerStateNotFoundError_base: {
-    new (options?: BaseErrorOptions): {
-        name: "TriggerStateNotFound";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "TriggerStateNotFound";
-        stack?: string;
-        cause?: unknown;
-    };
-    name: "TriggerStateNotFound";
-    is(error: unknown): error is BaseError;
-    wrap(options?: Omit<BaseErrorOptions, "cause"> & {
-        ifTypeDiffers?: boolean;
-    }): (error: unknown) => {
-        name: "TriggerStateNotFound";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "TriggerStateNotFound";
-        stack?: string;
-        cause?: unknown;
-    };
-    extend<Name extends string = string>(name: Name, message?: string): any;
-    isError(error: unknown): error is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-export declare class TriggerStateNotFoundError extends TriggerStateNotFoundError_base {
-}
-export {};
-//# sourceMappingURL=errors.d.ts.map

package/dist/types/src/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/errors.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;;;;;;;;;;;;;qBAiB4O,CAAC;;;;;;;;;;;;;;;AAf7S,qBAAa,wBAAyB,SAAQ,6BAAgE;gBAChG,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC;CAGzE;;;;;;;;;;;;;qBAW2S,CAAC;;;;;;;;;;;;;;;AAT7S,qBAAa,qBAAsB,SAAQ,0BAA0D;gBACvF,WAAW,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,gBAAgB,EAAE,SAAS,CAAC;CAG7E;;;;;;;;;;;;;qBAK2S,CAAC;;;;;;;;;;;;;;;AAH7S,qBAAa,aAAc,SAAQ,kBAA8D;CAAG;;;;;;;;;;;;;qBAGwM,CAAC;;;;;;;;;;;;;;;AAD7S,qBAAa,yBAA0B,SAAQ,8BAAmE;CAAG"}

package/dist/types/src/example/fib.d.ts

@@ -1,7 +0,0 @@
-declare const _default: import("..").FunctionDefinition<{
-    readonly iterations?: number | undefined;
-}, {
-    readonly result: string;
-}, import("..").FunctionServices>;
-export default _default;
-//# sourceMappingURL=fib.d.ts.map

package/dist/types/src/example/fib.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fib.d.ts","sourceRoot":"","sources":["../../../../src/example/fib.ts"],"names":[],"mappings":";;;;;AASA,wBAsBG"}

package/dist/types/src/example/forex-effect.d.ts

@@ -1,3 +0,0 @@
-declare const _default: any;
-export default _default;
-//# sourceMappingURL=forex-effect.d.ts.map