@dxos/functions 0.5.3-main.83788ff → 0.5.3-main.8ffbbae

package/src/runtime/scheduler.ts

@@ -2,16 +2,22 @@
 // Copyright 2023 DXOS.org
 //
 
+import { CronJob } from 'cron';
+import { getPort } from 'get-port-please';
+import http from 'node:http';
 import path from 'node:path';
+import WebSocket from 'ws';
 
-import { Mutex } from '@dxos/async';
-import { type Space } from '@dxos/client/echo';
+import { TextV0Type } from '@braneframe/types';
+import { debounce, DeferredTask, sleep, Trigger } from '@dxos/async';
+import { type Client, type PublicKey } from '@dxos/client';
+import { createSubscription, Filter, getAutomergeObjectCore, type Query, type Space } from '@dxos/client/echo';
 import { Context } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
+import { ComplexMap } from '@dxos/util';
 
-import { type FunctionRegistry } from '../function';
 import { type FunctionEventMeta } from '../handler';
-import { type TriggerRegistry } from '../trigger';
 import { type FunctionDef, type FunctionManifest, type FunctionTrigger } from '../types';
 
 export type Callback = (data: any) => Promise<void | number>;
@@ -25,87 +31,101 @@ export type SchedulerOptions = {
  * The scheduler triggers function execution based on various triggers.
  */
 export class Scheduler {
-  private _ctx = createContext();
-
-  private readonly _callMutex = new Mutex();
+  // Map of mounted functions.
+  private readonly _mounts = new ComplexMap<
+    { spaceKey: PublicKey; id: string },
+    { ctx: Context; trigger: FunctionTrigger }
+  >(({ spaceKey, id }) => `${spaceKey.toHex()}:${id}`);
 
   constructor(
-    public readonly functions: FunctionRegistry,
-    public readonly triggers: TriggerRegistry,
+    private readonly _client: Client,
+    private readonly _manifest: FunctionManifest,
     private readonly _options: SchedulerOptions = {},
-  ) {
-    this.functions.registered.on(async ({ space, added }) => {
-      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), added);
-    });
-    this.triggers.registered.on(async ({ space, triggers }) => {
-      await this._safeActivateTriggers(space, triggers, this.functions.getFunctions(space));
-    });
+  ) {}
+
+  get mounts() {
+    return Array.from(this._mounts.values()).reduce<FunctionTrigger[]>((acc, { trigger }) => {
+      acc.push(trigger);
+      return acc;
+    }, []);
   }
 
   async start() {
-    await this._ctx.dispose();
-    this._ctx = createContext();
-    await this.functions.open(this._ctx);
-    await this.triggers.open(this._ctx);
+    this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        await space.waitUntilReady();
+        for (const trigger of this._manifest.triggers ?? []) {
+          await this.mount(new Context(), space, trigger);
+        }
+      }
+    });
   }
 
   async stop() {
-    await this._ctx.dispose();
-    await this.functions.close();
-    await this.triggers.close();
+    for (const { id, spaceKey } of this._mounts.keys()) {
+      await this.unmount(id, spaceKey);
+    }
   }
 
-  // TODO(burdon): Remove and update registries directly.
-  public async register(space: Space, manifest: FunctionManifest) {
-    await this.functions.register(space, manifest.functions);
-    await this.triggers.register(space, manifest);
-  }
+  /**
+   * Mount trigger.
+   */
+  private async mount(ctx: Context, space: Space, trigger: FunctionTrigger) {
+    const key = { spaceKey: space.key, id: trigger.function };
+    const def = this._manifest.functions.find((config) => config.id === trigger.function);
+    invariant(def, `Function not found: ${trigger.function}`);
 
-  private async _safeActivateTriggers(
-    space: Space,
-    triggers: FunctionTrigger[],
-    functions: FunctionDef[],
-  ): Promise<void> {
-    const mountTasks = triggers.map((trigger) => {
-      return this.activate(space, functions, trigger);
-    });
-    await Promise.all(mountTasks).catch(log.catch);
-  }
+    // TODO(burdon): Currently supports only one trigger declaration per function.
+    const exists = this._mounts.get(key);
+    if (!exists) {
+      this._mounts.set(key, { ctx, trigger });
+      log('mount', { space: space.key, trigger });
+      if (ctx.disposed) {
+        return;
+      }
 
-  private async activate(space: Space, functions: FunctionDef[], fnTrigger: FunctionTrigger) {
-    const definition = functions.find((def) => def.uri === fnTrigger.function);
-    if (!definition) {
-      log.info('function is not found for trigger', { fnTrigger });
-      return;
-    }
+      //
+      // Triggers types.
+      //
 
-    await this.triggers.activate({ space }, fnTrigger, async (args) => {
-      return this._callMutex.executeSynchronized(() => {
-        return this._execFunction(definition, fnTrigger, {
-          meta: fnTrigger.meta,
-          data: { ...args, spaceKey: space.key },
-        });
-      });
-    });
+      if (trigger.timer) {
+        await this._createTimer(ctx, space, def, trigger);
+      }
+
+      if (trigger.webhook) {
+        await this._createWebhook(ctx, space, def, trigger);
+      }
+
+      if (trigger.websocket) {
+        await this._createWebsocket(ctx, space, def, trigger);
+      }
 
-    log('activated trigger', { space: space.key, trigger: fnTrigger });
+      if (trigger.subscription) {
+        await this._createSubscription(ctx, space, def, trigger);
+      }
+    }
   }
 
-  private async _execFunction<TData, TMeta>(
-    def: FunctionDef,
-    trigger: FunctionTrigger,
-    { data, meta }: { data: TData; meta?: TMeta },
-  ): Promise<number> {
+  private async unmount(id: string, spaceKey: PublicKey) {
+    const key = { id, spaceKey };
+    const { ctx } = this._mounts.get(key) ?? {};
+    if (ctx) {
+      this._mounts.delete(key);
+      await ctx.dispose();
+    }
+  }
+
+  private async _execFunction<TData, TMeta>(def: FunctionDef, trigger: FunctionTrigger, data: TData): Promise<number> {
     let status = 0;
     try {
       // TODO(burdon): Pass in Space key (common context)?
-      const payload = Object.assign({}, meta && ({ meta } satisfies FunctionEventMeta<TMeta>), data);
+      const payload = Object.assign({}, { meta: trigger.meta as TMeta } satisfies FunctionEventMeta<TMeta>, data);
 
       const { endpoint, callback } = this._options;
       if (endpoint) {
         // TODO(burdon): Move out of scheduler (generalize as callback).
-        const url = path.join(endpoint, def.route);
-        log.info('exec', { function: def.uri, url, triggerType: trigger.spec.type });
+        const url = path.join(endpoint, def.path);
+        log.info('exec', { function: def.id, url });
         const response = await fetch(url, {
           method: 'POST',
           headers: {
@@ -116,7 +136,7 @@ export class Scheduler {
 
         status = response.status;
       } else if (callback) {
-        log.info('exec', { function: def.uri });
+        log.info('exec', { function: def.id });
         status = (await callback(payload)) ?? 200;
       }
 
@@ -126,14 +146,226 @@ export class Scheduler {
       }
 
       // const result = await response.json();
-      log.info('done', { function: def.uri, status });
+      log.info('done', { function: def.id, status });
     } catch (err: any) {
-      log.error('error', { function: def.uri, error: err.message });
+      log.error('error', { function: def.id, error: err.message });
       status = 500;
     }
 
     return status;
   }
-}
 
-const createContext = () => new Context({ name: 'FunctionScheduler' });
+  //
+  // Triggers
+  //
+
+  /**
+   * Cron timer.
+   */
+  private async _createTimer(ctx: Context, space: Space, def: FunctionDef, trigger: FunctionTrigger) {
+    log.info('timer', { space: space.key, trigger });
+    const spec = trigger.timer!;
+
+    const task = new DeferredTask(ctx, async () => {
+      await this._execFunction(def, trigger, { spaceKey: space.key });
+    });
+
+    let last = 0;
+    let run = 0;
+    // https://www.npmjs.com/package/cron#constructor
+    const job = CronJob.from({
+      cronTime: spec.cron,
+      runOnInit: false,
+      onTick: () => {
+        // TODO(burdon): Check greater than 30s (use cron-parser).
+        const now = Date.now();
+        const delta = last ? now - last : 0;
+        last = now;
+
+        run++;
+        log.info('tick', { space: space.key.truncate(), count: run, delta });
+        task.schedule();
+      },
+    });
+
+    job.start();
+    ctx.onDispose(() => job.stop());
+  }
+
+  /**
+   * Webhook.
+   */
+  private async _createWebhook(ctx: Context, space: Space, def: FunctionDef, trigger: FunctionTrigger) {
+    log.info('webhook', { space: space.key, trigger });
+    const spec = trigger.webhook!;
+
+    // TODO(burdon): Enable POST hook with payload.
+    const server = http.createServer(async (req, res) => {
+      if (req.method !== spec.method) {
+        res.statusCode = 405;
+        return res.end();
+      }
+
+      res.statusCode = await this._execFunction(def, trigger, { spaceKey: space.key });
+      res.end();
+    });
+
+    // TODO(burdon): Not used.
+    // const DEF_PORT_RANGE = { min: 7500, max: 7599 };
+    // const portRange = Object.assign({}, trigger.port, DEF_PORT_RANGE) as WebhookTrigger['port'];
+    const port = await getPort({
+      random: true,
+      // portRange: [portRange!.min, portRange!.max],
+    });
+
+    // TODO(burdon): Update trigger object with actual port.
+    server.listen(port, () => {
+      log.info('started webhook', { port });
+      spec.port = port;
+    });
+
+    ctx.onDispose(() => {
+      server.close();
+    });
+  }
+
+  /**
+   * Websocket.
+   * NOTE: The port must be unique, so the same hook cannot be used for multiple spaces.
+   */
+  private async _createWebsocket(
+    ctx: Context,
+    space: Space,
+    def: FunctionDef,
+    trigger: FunctionTrigger,
+    options: {
+      retryDelay: number;
+      maxAttempts: number;
+    } = {
+      retryDelay: 2,
+      maxAttempts: 5,
+    },
+  ) {
+    log.info('websocket', { space: space.key, trigger });
+    const spec = trigger.websocket!;
+    const { url, init } = spec;
+
+    let ws: WebSocket;
+    for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+      const open = new Trigger<boolean>();
+
+      ws = new WebSocket(url);
+      Object.assign(ws, {
+        onopen: () => {
+          log.info('opened', { url });
+          if (spec.init) {
+            ws.send(new TextEncoder().encode(JSON.stringify(init)));
+          }
+
+          open.wake(true);
+        },
+
+        onclose: (event) => {
+          log.info('closed', { url, code: event.code });
+          // Reconnect if server closes (e.g., CF restart).
+          // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+          if (event.code === 1006) {
+            setTimeout(async () => {
+              log.info(`reconnecting in ${options.retryDelay}s...`, { url });
+              await this._createWebsocket(ctx, space, def, trigger, options);
+            }, options.retryDelay * 1_000);
+          }
+
+          open.wake(false);
+        },
+
+        onerror: (event) => {
+          log.catch(event.error, { url });
+        },
+
+        onmessage: async (event) => {
+          try {
+            const data = JSON.parse(new TextDecoder().decode(event.data as Uint8Array));
+            await this._execFunction(def, trigger, { spaceKey: space.key, data });
+          } catch (err) {
+            log.catch(err, { url });
+          }
+        },
+      } satisfies Partial<WebSocket>);
+
+      const isOpen = await open.wait();
+      if (isOpen) {
+        break;
+      } else {
+        const wait = Math.pow(attempt, 2) * options.retryDelay;
+        if (attempt < options.maxAttempts) {
+          log.warn(`failed to connect; trying again in ${wait}s`, { attempt });
+          await sleep(wait * 1_000);
+        }
+      }
+    }
+
+    ctx.onDispose(() => {
+      ws?.close();
+    });
+  }
+
+  /**
+   * ECHO subscription.
+   */
+  private async _createSubscription(ctx: Context, space: Space, def: FunctionDef, trigger: FunctionTrigger) {
+    log.info('subscription', { space: space.key, trigger });
+    const spec = trigger.subscription!;
+
+    const objectIds = new Set<string>();
+    const task = new DeferredTask(ctx, async () => {
+      await this._execFunction(def, trigger, { spaceKey: space.key, objects: Array.from(objectIds) });
+    });
+
+    // TODO(burdon): Don't fire initially?
+    // TODO(burdon): Create queue. Only allow one invocation per trigger at a time?
+    const subscriptions: (() => void)[] = [];
+    const subscription = createSubscription(({ added, updated }) => {
+      log.info('updated', { added: added.length, updated: updated.length });
+      for (const object of added) {
+        objectIds.add(object.id);
+      }
+      for (const object of updated) {
+        objectIds.add(object.id);
+      }
+
+      task.schedule();
+    });
+
+    subscriptions.push(() => subscription.unsubscribe());
+
+    // TODO(burdon): Disable trigger if keeps failing.
+    const { filter, options: { deep, delay } = {} } = spec;
+    const update = ({ objects }: Query) => {
+      subscription.update(objects);
+
+      // TODO(burdon): Hack to monitor changes to Document's text object.
+      if (deep) {
+        log.info('update', { objects: objects.length });
+        for (const object of objects) {
+          const content = object.content;
+          if (content instanceof TextV0Type) {
+            subscriptions.push(
+              getAutomergeObjectCore(content).updates.on(debounce(() => subscription.update([object]), 1_000)),
+            );
+          }
+        }
+      }
+    };
+
+    // TODO(burdon): Is Filter.or implemented?
+    // TODO(burdon): [Bug]: all callbacks are fired on the first mutation.
+    // TODO(burdon): [Bug]: not updated when document is deleted (either top or hierarchically).
+    const query = space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
+    subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
+
+    ctx.onDispose(() => {
+      subscriptions.forEach((unsubscribe) => unsubscribe());
+    });
+  }
+}

package/src/testing/test/handler.ts

@@ -4,12 +4,6 @@
 
 import { type FunctionHandler } from '../../handler';
 
-let callHandler: FunctionHandler<any> = async ({ response }) => response.status(200);
-
-export const setTestCallHandler = (handler: FunctionHandler<any>) => {
-  callHandler = handler;
-};
-
-export const handler: FunctionHandler<any> = async (args) => {
-  return callHandler(args);
+export const handler: FunctionHandler<any> = async ({ response }) => {
+  return response.status(200);
 };

package/src/types.ts

@@ -2,19 +2,28 @@
 // Copyright 2023 DXOS.org
 //
 
-import { RawObject, S, TypedObject } from '@dxos/echo-schema';
+import * as S from '@effect/schema/Schema';
 
-/**
- * Type discriminator for TriggerSpec.
- * Every spec has a type field of type FunctionTriggerType that we can use to understand which
- * type we're working with.
- * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
- */
-export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
+const TimerTriggerSchema = S.struct({
+  cron: S.string,
+});
+
+const WebhookTriggerSchema = S.mutable(
+  S.struct({
+    method: S.string,
+    // Assigned port.
+    port: S.optional(S.number),
+  }),
+);
+
+const WebsocketTriggerSchema = S.struct({
+  url: S.string,
+  init: S.optional(S.record(S.string, S.any)),
+});
 
 const SubscriptionTriggerSchema = S.struct({
-  type: S.literal('subscription'),
-  // TODO(burdon): Define query DSL (from ECHO).
+  spaceKey: S.optional(S.string),
+  // TODO(burdon): Define query DSL.
   filter: S.array(
     S.struct({
       type: S.string,
@@ -31,73 +40,48 @@ const SubscriptionTriggerSchema = S.struct({
   ),
 });
 
-export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
+const FunctionTriggerSchema = S.struct({
+  function: S.string.pipe(S.description('Function ID/URI.')),
 
-const TimerTriggerSchema = S.struct({
-  type: S.literal('timer'),
-  cron: S.string,
-});
+  // Context passed to function.
+  meta: S.optional(S.record(S.string, S.any)),
 
-export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
+  // Triggers.
+  timer: S.optional(TimerTriggerSchema),
+  webhook: S.optional(WebhookTriggerSchema),
+  websocket: S.optional(WebsocketTriggerSchema),
+  subscription: S.optional(SubscriptionTriggerSchema),
+});
 
-const WebhookTriggerSchema = S.mutable(
-  S.struct({
-    type: S.literal('webhook'),
-    method: S.string,
-    // Assigned port.
-    port: S.optional(S.number),
-  }),
-);
+export type FunctionTrigger = S.Schema.Type<typeof FunctionTriggerSchema>;
 
+export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
 export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
-
-const WebsocketTriggerSchema = S.struct({
-  type: S.literal('websocket'),
-  url: S.string,
-  init: S.optional(S.record(S.string, S.any)),
-});
-
 export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
-
-const TriggerSpecSchema = S.union(
-  TimerTriggerSchema,
-  WebhookTriggerSchema,
-  WebsocketTriggerSchema,
-  SubscriptionTriggerSchema,
-);
-
-export type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;
+export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
 
 /**
  * Function definition.
  */
-export class FunctionDef extends TypedObject({
-  typename: 'dxos.org/type/FunctionDef',
-  version: '0.1.0',
-})({
-  uri: S.string,
+// TODO(burdon): Name vs. path?
+const FunctionDefSchema = S.struct({
+  id: S.string,
+  // name: S.string,
   description: S.optional(S.string),
-  route: S.string,
+  // TODO(burdon): Rename route?
+  path: S.string,
   // TODO(burdon): NPM/GitHub/Docker/CF URL?
   handler: S.string,
-}) {}
+});
 
-export class FunctionTrigger extends TypedObject({
-  typename: 'dxos.org/type/FunctionTrigger',
-  version: '0.1.0',
-})({
-  function: S.string.pipe(S.description('Function URI.')),
-  // Context is merged into the event data passed to the function.
-  meta: S.optional(S.object),
-  spec: TriggerSpecSchema,
-}) {}
+export type FunctionDef = S.Schema.Type<typeof FunctionDefSchema>;
 
 /**
  * Function manifest file.
  */
 export const FunctionManifestSchema = S.struct({
-  functions: S.optional(S.mutable(S.array(RawObject(FunctionDef)))),
-  triggers: S.optional(S.mutable(S.array(RawObject(FunctionTrigger)))),
+  functions: S.mutable(S.array(FunctionDefSchema)),
+  triggers: S.optional(S.mutable(S.array(FunctionTriggerSchema))),
 });
 
 export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;

package/dist/types/src/function/function-registry.d.ts

@@ -1,24 +0,0 @@
-import { Event } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { type Space } from '@dxos/client/echo';
-import { type Context, Resource } from '@dxos/context';
-import { FunctionDef, type FunctionManifest } from '../types';
-export type FunctionsRegisteredEvent = {
-    space: Space;
-    added: FunctionDef[];
-};
-export declare class FunctionRegistry extends Resource {
-    private readonly _client;
-    private readonly _functionBySpaceKey;
-    readonly registered: Event<FunctionsRegisteredEvent>;
-    constructor(_client: Client);
-    getFunctions(space: Space): FunctionDef[];
-    /**
-     * Loads function definitions from the manifest into the space.
-     * We first load all the definitions from the space to deduplicate by functionId.
-     */
-    register(space: Space, functions: FunctionManifest['functions']): Promise<void>;
-    protected _open(): Promise<void>;
-    protected _close(_: Context): Promise<void>;
-}
-//# sourceMappingURL=function-registry.d.ts.map

package/dist/types/src/function/function-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function-registry.d.ts","sourceRoot":"","sources":["../../../../src/function/function-registry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAkB,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,KAAK,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKvD,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG9D,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB,CAAC;AAEF,qBAAa,gBAAiB,SAAQ,QAAQ;IAKhC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA4D;IAEhG,SAAgB,UAAU,kCAAyC;gBAEtC,OAAO,EAAE,MAAM;IAIrC,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,WAAW,EAAE;IAIhD;;;OAGG;IACU,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,gBAAgB,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;cAiBnE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;cAgCtB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAG3D"}

package/dist/types/src/function/function-registry.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=function-registry.test.d.ts.map

package/dist/types/src/function/function-registry.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function-registry.test.d.ts","sourceRoot":"","sources":["../../../../src/function/function-registry.test.ts"],"names":[],"mappings":""}

package/dist/types/src/function/index.d.ts

@@ -1,2 +0,0 @@
-export * from './function-registry';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/function/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/function/index.ts"],"names":[],"mappings":"AAIA,cAAc,qBAAqB,CAAC"}

package/dist/types/src/testing/functions-integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=functions-integration.test.d.ts.map

package/dist/types/src/testing/functions-integration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"functions-integration.test.d.ts","sourceRoot":"","sources":["../../../../src/testing/functions-integration.test.ts"],"names":[],"mappings":""}

package/dist/types/src/testing/index.d.ts

@@ -1,4 +0,0 @@
-export * from './setup';
-export * from './types';
-export * from './util';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/testing/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/testing/index.ts"],"names":[],"mappings":"AAIA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC"}

package/dist/types/src/testing/setup.d.ts

@@ -1,5 +0,0 @@
-import { Client, Config } from '@dxos/client';
-import { type TestBuilder } from '@dxos/client/testing';
-export declare const createInitializedClients: (testBuilder: TestBuilder, count?: number, config?: Config) => Promise<Client[]>;
-export declare const createFunctionRuntime: (testBuilder: TestBuilder) => Promise<Client>;
-//# sourceMappingURL=setup.d.ts.map

package/dist/types/src/testing/setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../src/testing/setup.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAQxD,eAAO,MAAM,wBAAwB,gBAAuB,WAAW,UAAS,MAAM,WAAe,MAAM,sBAW1G,CAAC;AAEF,eAAO,MAAM,qBAAqB,gBAAuB,WAAW,KAAG,QAAQ,MAAM,CAiBpF,CAAC"}

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

@@ -1,9 +0,0 @@
-declare const TestType_base: import("@dxos/echo-schema").EchoSchemaClass<{
-    title: string;
-} & {
-    id: string;
-}>;
-export declare class TestType extends TestType_base {
-}
-export {};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/testing/types.ts"],"names":[],"mappings":";;;;;AAMA,qBAAa,QAAS,SAAQ,aAE5B;CAAG"}

package/dist/types/src/testing/util.d.ts

@@ -1,3 +0,0 @@
-import { type Space } from '@dxos/client/echo';
-export declare const triggerWebhook: (space: Space, uri: string) => Promise<void>;
-//# sourceMappingURL=util.d.ts.map