@dxos/functions 0.8.4-main.67995b8 → 0.8.4-main.a4bbb77

package/src/types.ts

@@ -4,7 +4,8 @@
 
 import { Schema, SchemaAST } from 'effect';
 
-import { Expando, OptionsAnnotationId, TypedObject, Ref, RawObject } from '@dxos/echo-schema';
+import { Obj, QueryAST, Type } from '@dxos/echo';
+import { Expando, OptionsAnnotationId, RawObject, Ref } from '@dxos/echo-schema';
 import { DXN } from '@dxos/keys';
 
 import { FunctionType } from './schema';
@@ -14,13 +15,8 @@ import { FunctionType } from './schema';
  * 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 enum TriggerKind {
-  Timer = 'timer',
-  Webhook = 'webhook',
-  Subscription = 'subscription',
-  Email = 'email',
-  Queue = 'queue',
-}
+export const TriggerKinds = ['timer', 'webhook', 'subscription', 'email', 'queue'] as const;
+export type TriggerKind = (typeof TriggerKinds)[number];
 
 const kindLiteralAnnotations = { title: 'Kind' };
 
@@ -28,7 +24,7 @@ const kindLiteralAnnotations = { title: 'Kind' };
  * Cron timer.
  */
 const TimerTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Timer).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('timer').annotations(kindLiteralAnnotations),
   cron: Schema.String.annotations({
     title: 'Cron',
     [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
@@ -37,12 +33,14 @@ const TimerTriggerSchema = Schema.Struct({
 export type TimerTrigger = Schema.Schema.Type<typeof TimerTriggerSchema>;
 
 const EmailTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Email).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('email').annotations(kindLiteralAnnotations),
 }).pipe(Schema.mutable);
 export type EmailTrigger = Schema.Schema.Type<typeof EmailTriggerSchema>;
 
 const QueueTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Queue).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('queue').annotations(kindLiteralAnnotations),
+
+  // TODO(dmaretskyi): Change to a reference.
   queue: DXN.Schema,
 }).pipe(Schema.mutable);
 export type QueueTrigger = Schema.Schema.Type<typeof QueueTriggerSchema>;
@@ -51,7 +49,7 @@ export type QueueTrigger = Schema.Schema.Type<typeof QueueTriggerSchema>;
  * Webhook.
  */
 const WebhookTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Webhook).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('webhook').annotations(kindLiteralAnnotations),
   method: Schema.optional(
     Schema.String.annotations({
       title: 'Method',
@@ -66,19 +64,12 @@ const WebhookTriggerSchema = Schema.Struct({
 }).pipe(Schema.mutable);
 export type WebhookTrigger = Schema.Schema.Type<typeof WebhookTriggerSchema>;
 
-// TODO(burdon): Use ECHO definition (from https://github.com/dxos/dxos/pull/8233).
-const QuerySchema = Schema.Struct({
-  type: Schema.optional(Schema.String.annotations({ title: 'Type' })),
-  props: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-}).annotations({ title: 'Query' });
-
 /**
  * Subscription.
  */
 const SubscriptionTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Subscription).annotations(kindLiteralAnnotations),
-  // TODO(burdon): Define query DSL (from ECHO). Reconcile with Table.Query.
-  filter: QuerySchema,
+  kind: Schema.Literal('subscription').annotations(kindLiteralAnnotations),
+  query: QueryAST.Query.annotations({ title: 'Query' }),
   options: Schema.optional(
     Schema.Struct({
       // Watch changes to object (not just creation).
@@ -142,9 +133,23 @@ export const QueueTriggerOutput = Schema.mutable(
 );
 export type QueueTriggerOutput = Schema.Schema.Type<typeof QueueTriggerOutput>;
 
-export const SubscriptionTriggerOutput = Schema.mutable(
-  Schema.Struct({ type: Schema.String, changedObjectId: Schema.String }),
-);
+export const SubscriptionTriggerOutput = 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(Obj.Any),
+
+  /**
+   * @deprecated
+   */
+  changedObjectId: Schema.optional(Schema.String),
+}).pipe(Schema.mutable);
 export type SubscriptionTriggerOutput = Schema.Schema.Type<typeof SubscriptionTriggerOutput>;
 
 export const TimerTriggerOutput = Schema.mutable(Schema.Struct({ tick: Schema.Number }));
@@ -155,7 +160,7 @@ export type TimerTriggerOutput = Schema.Schema.Type<typeof TimerTriggerOutput>;
  * Function is invoked with the `payload` passed as input data.
  * The event that triggers the function is available in the function context.
  */
-export const FunctionTriggerSchema = Schema.Struct({
+const FunctionTrigger_ = Schema.Struct({
   /**
    * Function or workflow to invoke.
    */
@@ -185,17 +190,15 @@ export const FunctionTriggerSchema = Schema.Struct({
    * }
    */
   input: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
-});
-
-export type FunctionTriggerType = Schema.Schema.Type<typeof FunctionTriggerSchema>;
-
-/**
- * Function trigger.
- */
-export class FunctionTrigger extends TypedObject({
-  typename: 'dxos.org/type/FunctionTrigger',
-  version: '0.2.0',
-})(FunctionTriggerSchema.fields) {}
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/FunctionTrigger',
+    version: '0.2.0',
+  }),
+);
+export interface FunctionTrigger extends Schema.Schema.Type<typeof FunctionTrigger_> {}
+export interface FunctionTriggerEncoded extends Schema.Schema.Encoded<typeof FunctionTrigger_> {}
+export const FunctionTrigger: Schema.Schema<FunctionTrigger, FunctionTriggerEncoded> = FunctionTrigger_;
 
 // TODO(wittjosiah): Remove?
 

package/src/url.ts

@@ -6,7 +6,7 @@ import { type ObjectMeta } from '@dxos/echo-schema';
 import { type SpaceId } from '@dxos/keys';
 
 // TODO: use URL scheme for source?
-const FUNCTIONS_META_KEY = 'dxos.org/service/function';
+export const FUNCTIONS_META_KEY = 'dxos.org/service/function';
 
 export const FUNCTIONS_PRESET_META_KEY = 'dxos.org/service/function-preset';
 
@@ -14,32 +14,35 @@ const isSecure = (protocol: string) => {
   return protocol === 'https:' || protocol === 'wss:';
 };
 
-export const getUserFunctionUrlInMetadata = (meta: ObjectMeta) => {
+/**
+ * NOTE: functionId is backend ID, not ECHO object id.
+ */
+export const getUserFunctionIdInMetadata = (meta: ObjectMeta) => {
   return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
 };
 
-export const setUserFunctionUrlInMetadata = (meta: ObjectMeta, functionUrl: string) => {
+/**
+ * NOTE: functionId is backend ID, not ECHO object id.
+ */
+export const setUserFunctionIdInMetadata = (meta: ObjectMeta, functionId: string) => {
   const key = meta.keys.find((key) => key.source === FUNCTIONS_META_KEY);
   if (key) {
-    if (key.id !== functionUrl) {
+    if (key.id !== functionId) {
       throw new Error('Metadata mismatch');
     }
   } else {
-    meta.keys.push({ source: FUNCTIONS_META_KEY, id: functionUrl });
+    meta.keys.push({ source: FUNCTIONS_META_KEY, id: functionId });
   }
 };
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
  */
-export const makeFunctionUrl = (fn: { functionId: string }) => `/${fn.functionId}`;
-
-export const getInvocationUrl = (functionUrl: string, edgeUrl: string, options: InvocationOptions = {}) => {
+export const getInvocationUrl = (functionId: string, edgeUrl: string, options: InvocationOptions = {}) => {
   const baseUrl = new URL('functions/', edgeUrl);
 
   // Leading slashes cause the URL to be treated as an absolute path.
-  const relativeUrl = functionUrl.replace(/^\//, '');
-  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
+  const url = new URL(`./${functionId}`, baseUrl.toString());
   options.spaceId && url.searchParams.set('spaceId', options.spaceId);
   options.subjectId && url.searchParams.set('subjectId', options.subjectId);
   url.protocol = isSecure(url.protocol) ? 'https' : 'http';

package/dist/lib/browser/chunk-6PTFLPCO.mjs

@@ -1,462 +0,0 @@
-// src/services/database.ts
-import { Context, Effect, Layer } from "effect";
-var DatabaseService = class _DatabaseService extends Context.Tag("@dxos/functions/DatabaseService")() {
-  static {
-    this.notAvailable = Layer.succeed(_DatabaseService, {
-      get db() {
-        throw new Error("Database not available");
-      }
-    });
-  }
-  static {
-    this.make = (db) => {
-      return {
-        get db() {
-          return db;
-        }
-      };
-    };
-  }
-  static {
-    this.makeLayer = (db) => {
-      return Layer.succeed(_DatabaseService, _DatabaseService.make(db));
-    };
-  }
-  static {
-    this.resolve = Effect.fn(function* (dxn) {
-      const { db } = yield* _DatabaseService;
-      return yield* Effect.tryPromise({
-        try: () => db.graph.createRefResolver({
-          context: {
-            space: db.spaceId
-          }
-        }).resolve(dxn),
-        catch: (error) => error
-      });
-    });
-  }
-  static {
-    this.loadRef = Effect.fn(function* (ref) {
-      return yield* Effect.promise(() => ref.load());
-    });
-  }
-  static {
-    /**
-    * Creates a `QueryResult` object that can be subscribed to.
-    */
-    this.query = (queryOrFilter) => _DatabaseService.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("DatabaseService.query"));
-  }
-  static {
-    /**
-    * Executes the query once and returns the results.
-    */
-    this.runQuery = (queryOrFilter) => _DatabaseService.query(queryOrFilter).pipe(Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())));
-  }
-};
-
-// src/services/queues.ts
-import { Context as Context2, Layer as Layer2 } from "effect";
-var QueueService = class _QueueService extends Context2.Tag("@dxos/functions/QueueService")() {
-  static {
-    this.notAvailable = Layer2.succeed(_QueueService, {
-      queues: {
-        get(dxn) {
-          throw new Error("Queues not available");
-        },
-        create() {
-          throw new Error("Queues not available");
-        }
-      },
-      contextQueue: void 0
-    });
-  }
-  static {
-    this.make = (queues, contextQueue) => {
-      return {
-        queues,
-        contextQueue
-      };
-    };
-  }
-  static {
-    this.makeLayer = (queues, contextQueue) => Layer2.succeed(_QueueService, _QueueService.make(queues, contextQueue));
-  }
-};
-var ContextQueueService = class extends Context2.Tag("@dxos/functions/ContextQueueService")() {
-};
-
-// src/services/credentials.ts
-import { Context as Context3, Effect as Effect2, Layer as Layer3 } from "effect";
-var CredentialsService = class _CredentialsService extends Context3.Tag("@dxos/functions/CredentialsService")() {
-  static {
-    this.configuredLayer = (credentials) => Layer3.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
-  }
-  static {
-    this.getCredential = (query) => Effect2.gen(function* () {
-      const credentials = yield* _CredentialsService;
-      return yield* Effect2.promise(() => credentials.getCredential(query));
-    });
-  }
-};
-var ConfiguredCredentialsService = class {
-  constructor(credentials = []) {
-    this.credentials = credentials;
-  }
-  addCredentials(credentials) {
-    this.credentials.push(...credentials);
-    return this;
-  }
-  async queryCredentials(query) {
-    return this.credentials.filter((credential) => credential.service === query.service);
-  }
-  async getCredential(query) {
-    const credential = this.credentials.find((credential2) => credential2.service === query.service);
-    if (!credential) {
-      throw new Error(`Credential not found for service: ${query.service}`);
-    }
-    return credential;
-  }
-};
-
-// src/services/tracing.ts
-import { Context as Context4, Effect as Effect3, Layer as Layer4 } from "effect";
-import { AgentStatus } from "@dxos/ai";
-import { Obj } from "@dxos/echo";
-var TracingService = class _TracingService extends Context4.Tag("@dxos/functions/TracingService")() {
-  static {
-    this.noop = {
-      write: () => {
-      }
-    };
-  }
-  static {
-    this.layerNoop = Layer4.succeed(_TracingService, _TracingService.noop);
-  }
-  static {
-    this.console = {
-      write: (event) => {
-        console.log(event);
-      }
-    };
-  }
-  static {
-    /**
-    * Emit the current human-readable execution status.
-    */
-    this.emitStatus = Effect3.fnUntraced(function* (data) {
-      const tracing = yield* _TracingService;
-      tracing.write(Obj.make(AgentStatus, data));
-    });
-  }
-};
-
-// src/services/event-logger.ts
-import { Effect as Effect4, Context as Context5, Schema, Layer as Layer5 } from "effect";
-import { Obj as Obj2, Type } from "@dxos/echo";
-import { invariant } from "@dxos/invariant";
-import { log, LogLevel } from "@dxos/log";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/event-logger.ts";
-var ComputeEventPayload = Schema.Union(Schema.Struct({
-  type: Schema.Literal("begin-compute"),
-  nodeId: Schema.String,
-  inputs: Schema.Record({
-    key: Schema.String,
-    value: Schema.Any
-  })
-}), Schema.Struct({
-  type: Schema.Literal("end-compute"),
-  nodeId: Schema.String,
-  outputs: Schema.Record({
-    key: Schema.String,
-    value: Schema.Any
-  })
-}), Schema.Struct({
-  type: Schema.Literal("compute-input"),
-  nodeId: Schema.String,
-  property: Schema.String,
-  value: Schema.Any
-}), Schema.Struct({
-  type: Schema.Literal("compute-output"),
-  nodeId: Schema.String,
-  property: Schema.String,
-  value: Schema.Any
-}), Schema.Struct({
-  type: Schema.Literal("custom"),
-  nodeId: Schema.String,
-  event: Schema.Any
-}));
-var ComputeEvent = Schema.Struct({
-  payload: ComputeEventPayload
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/ComputeEvent",
-  version: "0.1.0"
-}));
-var ComputeEventLogger = class _ComputeEventLogger extends Context5.Tag("@dxos/functions/ComputeEventLogger")() {
-  static {
-    this.noop = {
-      log: () => {
-      },
-      nodeId: void 0
-    };
-  }
-  static {
-    /**
-    * Implements ComputeEventLogger using TracingService.
-    */
-    this.layerFromTracing = Layer5.effect(_ComputeEventLogger, Effect4.gen(function* () {
-      const tracing = yield* TracingService;
-      return {
-        log: (event) => {
-          tracing.write(Obj2.make(ComputeEvent, {
-            payload: event
-          }));
-        },
-        nodeId: void 0
-      };
-    }));
-  }
-};
-var logCustomEvent = (data) => Effect4.gen(function* () {
-  const logger = yield* ComputeEventLogger;
-  if (!logger.nodeId) {
-    throw new Error("logCustomEvent must be called within a node compute function");
-  }
-  logger.log({
-    type: "custom",
-    nodeId: logger.nodeId,
-    event: data
-  });
-});
-var createDefectLogger = () => Effect4.catchAll((error) => Effect4.gen(function* () {
-  log.error("unhandled effect error", {
-    error
-  }, {
-    F: __dxlog_file,
-    L: 93,
-    S: this,
-    C: (f, a) => f(...a)
-  });
-  throw error;
-}));
-var createEventLogger = (level, message = "event") => {
-  const logFunction = {
-    [LogLevel.WARN]: log.warn,
-    [LogLevel.VERBOSE]: log.verbose,
-    [LogLevel.DEBUG]: log.debug,
-    [LogLevel.INFO]: log.info,
-    [LogLevel.ERROR]: log.error
-  }[level];
-  invariant(logFunction, void 0, {
-    F: __dxlog_file,
-    L: 111,
-    S: void 0,
-    A: [
-      "logFunction",
-      ""
-    ]
-  });
-  return {
-    log: (event) => {
-      logFunction(message, event);
-    },
-    nodeId: void 0
-  };
-};
-
-// src/services/remote-function-execution-service.ts
-import { Context as Context6, Layer as Layer6 } from "effect";
-var RemoteFunctionExecutionService = class _RemoteFunctionExecutionService extends Context6.Tag("@dxos/functions/RemoteFunctionExecutionService")() {
-  static fromClient(baseUrl, spaceId) {
-    return {
-      callFunction: async (deployedFunctionId, input) => {
-        const url = getInvocationUrl(deployedFunctionId, baseUrl, {
-          spaceId
-        });
-        const result = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(input)
-        });
-        if (result.status >= 300 || result.status < 200) {
-          throw new Error("Failed to invoke function", {
-            cause: new Error(`HTTP error: ${await result.text()}`)
-          });
-        }
-        return await result.json();
-      }
-    };
-  }
-  static {
-    this.mock = () => {
-      return {
-        callFunction: async (deployedFunctionId, input) => {
-          return input;
-        }
-      };
-    };
-  }
-  static {
-    this.mockLayer = Layer6.succeed(_RemoteFunctionExecutionService, _RemoteFunctionExecutionService.mock());
-  }
-};
-var getInvocationUrl = (functionUrl, edgeUrl, options = {}) => {
-  const baseUrl = new URL("functions/", edgeUrl);
-  const relativeUrl = functionUrl.replace(/^\//, "");
-  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
-  options.spaceId && url.searchParams.set("spaceId", options.spaceId);
-  options.subjectId && url.searchParams.set("subjectId", options.subjectId);
-  url.protocol = isSecure(url.protocol) ? "https" : "http";
-  return url.toString();
-};
-var isSecure = (protocol) => {
-  return protocol === "https:" || protocol === "wss:";
-};
-
-// src/services/service-container.ts
-import { Layer as Layer7 } from "effect";
-import { AiService } from "@dxos/ai";
-import { entries } from "@dxos/util";
-var SERVICES = {
-  ai: AiService,
-  credentials: CredentialsService,
-  database: DatabaseService,
-  eventLogger: ComputeEventLogger,
-  functionCallService: RemoteFunctionExecutionService,
-  queues: QueueService,
-  tracing: TracingService
-};
-var SERVICE_MAPPING = Object.fromEntries(entries(SERVICES).map(([name, tag]) => [
-  tag.key,
-  name
-]));
-var SERVICE_TAGS = Object.values(SERVICES);
-var DEFAULT_SERVICES = {
-  tracing: TracingService.noop
-};
-var ServiceContainer = class _ServiceContainer {
-  constructor() {
-    this._services = {
-      ...DEFAULT_SERVICES
-    };
-  }
-  /**
-  * Set services.
-  * @param services - Services to set.
-  * @returns The container instance.
-  */
-  setServices(services) {
-    this._services = {
-      ...this._services,
-      ...services
-    };
-    return this;
-  }
-  getService(tag) {
-    const serviceKey = SERVICE_MAPPING[tag.key];
-    const service = serviceKey != null ? this._services[serviceKey] : void 0;
-    if (!service) {
-      throw new Error(`Service not available: ${tag.key}`);
-    }
-    return service;
-  }
-  clone() {
-    return new _ServiceContainer().setServices({
-      ...this._services
-    });
-  }
-  // TODO(dmaretskyi): `getService` is designed to error at runtime if the service is not available, but layer forces us to provide all services and makes stubs for the ones that are not available.
-  createLayer() {
-    const ai = this._services.ai != null ? Layer7.succeed(AiService, this._services.ai) : AiService.notAvailable;
-    const credentials = Layer7.succeed(CredentialsService, this._services.credentials ?? new ConfiguredCredentialsService());
-    const database = this._services.database != null ? Layer7.succeed(DatabaseService, this._services.database) : DatabaseService.notAvailable;
-    const queues = this._services.queues != null ? Layer7.succeed(QueueService, this._services.queues) : QueueService.notAvailable;
-    const tracing = Layer7.succeed(TracingService, this._services.tracing ?? TracingService.noop);
-    const eventLogger = Layer7.succeed(ComputeEventLogger, this._services.eventLogger ?? ComputeEventLogger.noop);
-    const functionCallService = Layer7.succeed(RemoteFunctionExecutionService, this._services.functionCallService ?? RemoteFunctionExecutionService.mock());
-    return Layer7.mergeAll(ai, credentials, database, queues, tracing, eventLogger, functionCallService);
-  }
-};
-
-// src/errors.ts
-import { BaseError } from "@dxos/errors";
-var ServiceNotAvailableError = class extends BaseError.extend("SERVICE_NOT_AVAILABLE") {
-  constructor(serviceName) {
-    super(`Service not available: ${serviceName}`);
-  }
-};
-var FunctionError = class extends BaseError.extend("FUNCTION_ERROR") {
-};
-
-// src/services/local-function-execution.ts
-import { Context as Context7, Effect as Effect5, Layer as Layer8, Schema as Schema2 } from "effect";
-import { todo } from "@dxos/debug";
-var LocalFunctionExecutionService = class _LocalFunctionExecutionService extends Context7.Tag("@dxos/functions/LocalFunctionExecutionService")() {
-  static {
-    this.layer = Layer8.succeed(_LocalFunctionExecutionService, {
-      invokeFunction: (fnDef, input) => invokeFunction(fnDef, input)
-    });
-  }
-};
-var invokeFunction = (fnDef, input) => Effect5.gen(function* () {
-  const assertInput = fnDef.inputSchema.pipe(Schema2.asserts);
-  assertInput(input);
-  const context = {
-    getService: () => todo(),
-    getSpace: async (_spaceId) => {
-      throw new Error("Not available. Use the database service instead.");
-    },
-    space: void 0,
-    get ai() {
-      throw new Error("Not available. Use the ai service instead.");
-    }
-  };
-  const data = yield* Effect5.gen(function* () {
-    const result = fnDef.handler({
-      context,
-      data: input
-    });
-    if (Effect5.isEffect(result)) {
-      return yield* result.pipe(Effect5.orDie);
-    } else if (typeof result === "object" && result !== null && "then" in result && typeof result.then === "function") {
-      return yield* Effect5.promise(() => result);
-    } else {
-      return result;
-    }
-  }).pipe(Effect5.orDie, Effect5.catchAllDefect((defect) => Effect5.die(new FunctionError("Error running function", {
-    context: {
-      name: fnDef.name
-    },
-    cause: defect
-  }))));
-  const assertOutput = fnDef.outputSchema?.pipe(Schema2.asserts);
-  assertOutput(data);
-  return data;
-}).pipe(Effect5.withSpan("invokeFunction", {
-  attributes: {
-    name: fnDef.name
-  }
-}));
-
-export {
-  DatabaseService,
-  QueueService,
-  ContextQueueService,
-  CredentialsService,
-  ConfiguredCredentialsService,
-  TracingService,
-  ComputeEventPayload,
-  ComputeEvent,
-  ComputeEventLogger,
-  logCustomEvent,
-  createDefectLogger,
-  createEventLogger,
-  RemoteFunctionExecutionService,
-  SERVICE_TAGS,
-  ServiceContainer,
-  ServiceNotAvailableError,
-  FunctionError,
-  LocalFunctionExecutionService
-};
-//# sourceMappingURL=chunk-6PTFLPCO.mjs.map