@dxos/functions 0.7.5-labs.e27f9b9 → 0.7.5-labs.f400bbc

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

@@ -8,7 +8,8 @@ export declare enum TriggerKind {
     Timer = "timer",
     Webhook = "webhook",
     Subscription = "subscription",
-    Email = "email"
+    Email = "email",
+    Queue = "queue"
 }
 /**
  * Cron timer.
@@ -22,6 +23,11 @@ declare const EmailTriggerSchema: S.mutable<S.Struct<{
     type: S.Literal<[TriggerKind.Email]>;
 }>>;
 export type EmailTrigger = S.Schema.Type<typeof EmailTriggerSchema>;
+declare const QueueTriggerSchema: S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Queue]>;
+    queue: S.refine<string, S.Schema<string, string, never>>;
+}>>;
+export type QueueTrigger = S.Schema.Type<typeof QueueTriggerSchema>;
 /**
  * Webhook.
  */
@@ -68,6 +74,9 @@ export declare const TriggerSchema: S.Union<[S.mutable<S.Struct<{
     }>>;
 }>>, S.mutable<S.Struct<{
     type: S.Literal<[TriggerKind.Email]>;
+}>>, S.mutable<S.Struct<{
+    type: S.Literal<[TriggerKind.Queue]>;
+    queue: S.refine<string, S.Schema<string, string, never>>;
 }>>]>;
 export type TriggerType = S.Schema.Type<typeof TriggerSchema>;
 /**
@@ -95,11 +104,14 @@ export declare const FunctionTriggerSchema: S.Struct<{
         }>>;
     }>>, S.mutable<S.Struct<{
         type: S.Literal<[TriggerKind.Email]>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Queue]>;
+        queue: S.refine<string, S.Schema<string, string, never>>;
     }>>]>>;
     meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
 }>;
 export type FunctionTriggerType = S.Schema.Type<typeof FunctionTriggerSchema>;
-declare const FunctionTrigger_base: import("@dxos/echo-schema").TypedObjectPrototype<import("packages/core/echo/echo-schema/dist/types/src/object/common").TypedObjectFields<{
+declare const FunctionTrigger_base: import("@dxos/echo-schema").TypedObjectPrototype<import("@dxos/echo-schema").TypedObjectFields<{
     readonly function: S.optional<S.SchemaClass<string, string, never>>;
     readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
     readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
@@ -121,9 +133,12 @@ declare const FunctionTrigger_base: import("@dxos/echo-schema").TypedObjectProto
         }>>;
     }>>, S.mutable<S.Struct<{
         type: S.Literal<[TriggerKind.Email]>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Queue]>;
+        queue: S.refine<string, S.Schema<string, string, never>>;
     }>>]>>;
     readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
-}, import("packages/core/echo/echo-schema/dist/types/src/object/common").TypedObjectOptions>, S.Struct.Encoded<{
+}, import("@dxos/echo-schema").TypedObjectOptions>, S.Struct.Encoded<{
     readonly function: S.optional<S.SchemaClass<string, string, never>>;
     readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
     readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
@@ -145,6 +160,9 @@ declare const FunctionTrigger_base: import("@dxos/echo-schema").TypedObjectProto
         }>>;
     }>>, S.mutable<S.Struct<{
         type: S.Literal<[TriggerKind.Email]>;
+    }>>, S.mutable<S.Struct<{
+        type: S.Literal<[TriggerKind.Queue]>;
+        queue: S.refine<string, S.Schema<string, string, never>>;
     }>>]>>;
     readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
 }>>;
@@ -153,12 +171,12 @@ declare const FunctionTrigger_base: import("@dxos/echo-schema").TypedObjectProto
  */
 export declare class FunctionTrigger extends FunctionTrigger_base {
 }
-declare const FunctionDef_base: import("@dxos/echo-schema").TypedObjectPrototype<import("packages/core/echo/echo-schema/dist/types/src/object/common").TypedObjectFields<{
+declare const FunctionDef_base: import("@dxos/echo-schema").TypedObjectPrototype<import("@dxos/echo-schema").TypedObjectFields<{
     uri: typeof S.String;
     description: S.optional<typeof S.String>;
     route: typeof S.String;
     handler: typeof S.String;
-}, import("packages/core/echo/echo-schema/dist/types/src/object/common").TypedObjectOptions>, S.Struct.Encoded<{
+}, import("@dxos/echo-schema").TypedObjectOptions>, S.Struct.Encoded<{
     uri: typeof S.String;
     description: S.optional<typeof S.String>;
     route: typeof S.String;
@@ -174,18 +192,18 @@ export declare class FunctionDef extends FunctionDef_base {
  * Function manifest file.
  */
 export declare const FunctionManifestSchema: S.Struct<{
-    functions: S.optional<S.mutable<S.Array$<S.Schema<import("@dxos/echo-schema").ExcludeId<import("packages/core/echo/echo-schema/dist/types/src/object/common").TypedObjectFields<{
+    functions: S.optional<S.mutable<S.Array$<S.Schema<import("@dxos/echo-schema").ExcludeId<import("@dxos/echo-schema").TypedObjectFields<{
         uri: typeof S.String;
         description: S.optional<typeof S.String>;
         route: typeof S.String;
         handler: typeof S.String;
-    }, import("packages/core/echo/echo-schema/dist/types/src/object/common").TypedObjectOptions>> & import("@dxos/echo-schema").WithMeta, S.Struct.Encoded<{
+    }, import("@dxos/echo-schema").TypedObjectOptions>> & import("@dxos/echo-schema").WithMeta, S.Struct.Encoded<{
         uri: typeof S.String;
         description: S.optional<typeof S.String>;
         route: typeof S.String;
         handler: typeof S.String;
     }>, never>>>>;
-    triggers: S.optional<S.mutable<S.Array$<S.Schema<import("@dxos/echo-schema").ExcludeId<import("packages/core/echo/echo-schema/dist/types/src/object/common").TypedObjectFields<{
+    triggers: S.optional<S.mutable<S.Array$<S.Schema<import("@dxos/echo-schema").ExcludeId<import("@dxos/echo-schema").TypedObjectFields<{
         readonly function: S.optional<S.SchemaClass<string, string, never>>;
         readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
         readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
@@ -207,9 +225,12 @@ export declare const FunctionManifestSchema: S.Struct<{
             }>>;
         }>>, S.mutable<S.Struct<{
             type: S.Literal<[TriggerKind.Email]>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Queue]>;
+            queue: S.refine<string, S.Schema<string, string, never>>;
         }>>]>>;
         readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
-    }, import("packages/core/echo/echo-schema/dist/types/src/object/common").TypedObjectOptions>> & import("@dxos/echo-schema").WithMeta, S.Struct.Encoded<{
+    }, import("@dxos/echo-schema").TypedObjectOptions>> & import("@dxos/echo-schema").WithMeta, S.Struct.Encoded<{
         readonly function: S.optional<S.SchemaClass<string, string, never>>;
         readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
         readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
@@ -231,6 +252,9 @@ export declare const FunctionManifestSchema: S.Struct<{
             }>>;
         }>>, S.mutable<S.Struct<{
             type: S.Literal<[TriggerKind.Email]>;
+        }>>, S.mutable<S.Struct<{
+            type: S.Literal<[TriggerKind.Queue]>;
+            queue: S.refine<string, S.Schema<string, string, never>>;
         }>>]>>;
         readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
     }>, never>>>>;

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/types/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuC,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAExF;;;;GAIG;AACH,oBAAY,WAAW;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,KAAK,UAAU;CAChB;AAKD;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;GAMN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,kBAAkB;;GAEN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;GAaR,CAAC;AAEnB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAQxE;;GAEG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;;;GAYb,CAAC;AAEnB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;KAQxB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;EAYhC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAGL;CAAG;;;;;;;;;;;;AAEnC;;;GAGG;AAEH,qBAAa,WAAY,SAAQ,gBAQ/B;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,cAAc,iDAAiC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/types/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuC,CAAC,EAAoB,MAAM,mBAAmB,CAAC;AAE7F;;;;GAIG;AACH,oBAAY,WAAW;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAKD;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;GAMN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,kBAAkB;;GAEN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,kBAAkB;;;GAGN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;GAaR,CAAC;AAEnB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAQxE;;GAEG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;;;GAYb,CAAC;AAEnB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;KAQxB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAahC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAGL;CAAG;;;;;;;;;;;;AAEnC;;;GAGG;AAEH,qBAAa,WAAY,SAAQ,gBAQ/B;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,cAAc,iDAAiC,CAAC"}

package/package.json

@@ -1,18 +1,24 @@
 {
   "name": "@dxos/functions",
-  "version": "0.7.5-labs.e27f9b9",
+  "version": "0.7.5-labs.f400bbc",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
   "author": "info@dxos.org",
   "sideEffects": true,
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
     },
+    "./bundler": {
+      "types": "./dist/types/src/bundler/index.d.ts",
+      "browser": "./dist/lib/browser/bundler/index.mjs",
+      "node": "./dist/lib/node-esm/bundler/index.mjs"
+    },
     "./edge": {
       "types": "./dist/types/src/edge/index.d.ts",
       "browser": "./dist/lib/browser/edge/index.mjs",
@@ -32,11 +38,17 @@
   "types": "dist/types/src/index.d.ts",
   "typesVersions": {
     "*": {
+      "bundler": [
+        "dist/types/src/bundler/index.d.ts"
+      ],
+      "edge": [
+        "dist/types/src/edge/index.d.ts"
+      ],
       "testing": [
         "dist/types/src/testing/index.d.ts"
       ],
       "types": [
-        "dist/types/src/types.d.ts"
+        "dist/types/src/types/index.d.ts"
       ]
     }
   },
@@ -50,30 +62,32 @@
     "@preact/signals-core": "^1.6.0",
     "cron": "^3.1.6",
     "effect": "^3.12.3",
+    "esbuild-wasm": "^0.16.14",
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
     "iso-did": "^1.6.0",
     "ws": "^8.14.2",
-    "@dxos/async": "0.7.5-labs.e27f9b9",
-    "@dxos/client": "0.7.5-labs.e27f9b9",
-    "@dxos/echo-db": "0.7.5-labs.e27f9b9",
-    "@dxos/context": "0.7.5-labs.e27f9b9",
-    "@dxos/echo-protocol": "0.7.5-labs.e27f9b9",
-    "@dxos/echo-schema": "0.7.5-labs.e27f9b9",
-    "@dxos/invariant": "0.7.5-labs.e27f9b9",
-    "@dxos/live-object": "0.7.5-labs.e27f9b9",
-    "@dxos/edge-client": "0.7.5-labs.e27f9b9",
-    "@dxos/log": "0.7.5-labs.e27f9b9",
-    "@dxos/node-std": "0.7.5-labs.e27f9b9",
-    "@dxos/schema": "0.7.5-labs.e27f9b9",
-    "@dxos/protocols": "0.7.5-labs.e27f9b9",
-    "@dxos/keys": "0.7.5-labs.e27f9b9",
-    "@dxos/util": "0.7.5-labs.e27f9b9"
+    "@dxos/async": "0.7.5-labs.f400bbc",
+    "@dxos/context": "0.7.5-labs.f400bbc",
+    "@dxos/client": "0.7.5-labs.f400bbc",
+    "@dxos/echo-db": "0.7.5-labs.f400bbc",
+    "@dxos/echo-protocol": "0.7.5-labs.f400bbc",
+    "@dxos/echo-schema": "0.7.5-labs.f400bbc",
+    "@dxos/crypto": "0.7.5-labs.f400bbc",
+    "@dxos/edge-client": "0.7.5-labs.f400bbc",
+    "@dxos/invariant": "0.7.5-labs.f400bbc",
+    "@dxos/keys": "0.7.5-labs.f400bbc",
+    "@dxos/live-object": "0.7.5-labs.f400bbc",
+    "@dxos/log": "0.7.5-labs.f400bbc",
+    "@dxos/node-std": "0.7.5-labs.f400bbc",
+    "@dxos/schema": "0.7.5-labs.f400bbc",
+    "@dxos/protocols": "0.7.5-labs.f400bbc",
+    "@dxos/util": "0.7.5-labs.f400bbc"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.7.5-labs.e27f9b9"
+    "@dxos/agent": "0.7.5-labs.f400bbc"
   },
   "publishConfig": {
     "access": "public"

package/src/bundler/bundler.test.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+// @ts-ignore
+import wasmUrl from 'esbuild-wasm/esbuild.wasm?url';
+import { beforeAll, describe, expect, test } from 'vitest';
+
+import { isNode } from '@dxos/util';
+
+import { Bundler, initializeBundler } from './bundler';
+
+describe('Bundler', () => {
+  beforeAll(async () => {
+    if (!isNode()) {
+      await initializeBundler({ wasmUrl });
+    }
+  });
+
+  test('Basic', async () => {
+    const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
+    const result = await bundler.bundle({ source: 'const x = 100' }); // TODO(burdon): Test import.
+    expect(result.bundle).to.exist;
+    expect(result.error).to.not.exist;
+  });
+
+  test('Import', async () => {
+    const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
+    const result = await bundler.bundle({
+      source: `
+      import { Filter } from './runtime.js';
+
+      const query = Filter.typename('dxos.org/type/Example');
+    `,
+    });
+    expect(result.bundle).to.exist;
+    expect(result.error).to.not.exist;
+  });
+
+  // TODO(dmaretskyi): Flaky on CI: https://cloud.nx.app/runs/Hjcifa8Ccq/task/plugin-script%3Atest
+  test.skip('HTTPS Import', async () => {
+    const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
+    const result = await bundler.bundle({
+      source: `
+      import { invariant } from 'https://esm.sh/@dxos/invariant';
+      invariant(true);
+    `,
+    });
+    expect(result.bundle).to.exist;
+    expect(result.error).to.not.exist;
+  });
+
+  test('Error', async () => {
+    const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
+    const result = await bundler.bundle({ source: "import missing from './module'; missing();" });
+    expect(result.bundle).to.not.exist;
+    expect(result.error).to.exist;
+  });
+});

package/src/bundler/bundler.ts

@@ -0,0 +1,264 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type BuildOptions } from 'esbuild';
+import { build, initialize, type BuildResult, type Plugin } from 'esbuild-wasm';
+
+import { subtleCrypto } from '@dxos/crypto';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+
+export type Import = {
+  moduleUrl: string;
+  defaultImport: boolean;
+  namedImports: string[];
+};
+
+export type BundleOptions = {
+  /**
+   * Path to the source file on the local file system.
+   * If provided, the path will be used instead of the `source` code.
+   */
+  path?: string;
+
+  /**
+   * Source code to bundle.
+   * Required if `path` is not provided.
+   */
+  source?: string;
+};
+
+export type BundleResult = {
+  timestamp: number;
+  sourceHash?: Buffer;
+  imports?: Import[];
+  bundle?: string;
+  error?: any;
+};
+
+export type BundlerOptions = {
+  platform: BuildOptions['platform'];
+  sandboxedModules: string[];
+  remoteModules: Record<string, string>;
+};
+
+let initialized: Promise<void>;
+export const initializeBundler = async (options: { wasmUrl: string }) => {
+  await (initialized ??= initialize({
+    wasmURL: options.wasmUrl,
+  }));
+};
+
+/**
+ * ESBuild bundler.
+ */
+export class Bundler {
+  constructor(private readonly _options: BundlerOptions) {}
+
+  async bundle({ path, source }: BundleOptions): Promise<BundleResult> {
+    const { sandboxedModules: providedModules, ...options } = this._options;
+
+    const createResult = async (result?: Partial<BundleResult>) => {
+      return {
+        timestamp: Date.now(),
+        sourceHash: source ? Buffer.from(await subtleCrypto.digest('SHA-256', Buffer.from(source))) : undefined,
+        ...result,
+      };
+    };
+
+    if (this._options.platform === 'browser') {
+      invariant(initialized, 'Compiler not initialized.');
+      await initialized;
+    }
+
+    const imports = source ? analyzeSourceFileImports(source) : [];
+
+    // https://esbuild.github.io/api/#build
+    try {
+      const result = await build({
+        platform: options.platform,
+        conditions: ['workerd', 'browser'],
+        metafile: true,
+        write: false,
+        entryPoints: [path ?? 'memory:main.tsx'],
+        bundle: true,
+        format: 'esm',
+        plugins: [
+          {
+            name: 'memory',
+            setup: (build) => {
+              build.onResolve({ filter: /^\.\/runtime\.js$/ }, ({ path }) => {
+                return { path, external: true };
+              });
+
+              build.onResolve({ filter: /^dxos:functions$/ }, ({ path }) => {
+                return { path: './runtime.js', external: true };
+              });
+
+              build.onResolve({ filter: /^memory:/ }, ({ path }) => {
+                return { path: path.split(':')[1], namespace: 'memory' };
+              });
+
+              build.onLoad({ filter: /.*/, namespace: 'memory' }, ({ path }) => {
+                if (path === 'main.tsx') {
+                  return {
+                    contents: source,
+                    loader: 'tsx',
+                  };
+                }
+              });
+
+              for (const module of providedModules) {
+                build.onResolve({ filter: new RegExp(`^${module}$`) }, ({ path }) => {
+                  return { path, namespace: 'injected-module' };
+                });
+              }
+
+              build.onLoad({ filter: /.*/, namespace: 'injected-module' }, ({ path }) => {
+                const namedImports = imports.find((entry) => entry.moduleIdentifier === path)?.namedImports ?? [];
+                return {
+                  contents: `
+                  const { ${namedImports.join(',')} } = window.__DXOS_SANDBOX_MODULES__[${JSON.stringify(path)}];
+                  export { ${namedImports.join(',')} };
+                  export default window.__DXOS_SANDBOX_MODULES__[${JSON.stringify(path)}].default;
+                `,
+                  loader: 'tsx',
+                };
+              });
+            },
+          },
+          httpPlugin,
+        ],
+      });
+
+      log('compile complete', result.metafile);
+
+      return await createResult({
+        imports: this.analyzeImports(result),
+        bundle: result.outputFiles![0].text,
+      });
+    } catch (err) {
+      return await createResult({ error: err });
+    }
+  }
+
+  // TODO(dmaretskyi): In the future we can replace the compiler with SWC with plugins running in WASM.
+  analyzeImports(result: BuildResult): Import[] {
+    invariant(result.outputFiles);
+
+    // TODO(dmaretskyi): Support import aliases and wildcard imports.
+    const parsedImports = allMatches(IMPORT_REGEX, result.outputFiles[0].text);
+    return Object.values(result.metafile!.outputs)[0].imports.map((entry): Import => {
+      const namedImports: string[] = [];
+
+      const parsedImport = parsedImports.find((capture) => capture?.[4] === entry.path);
+      if (parsedImport?.[2]) {
+        NAMED_IMPORTS_REGEX.lastIndex = 0;
+        const namedImportsMatch = NAMED_IMPORTS_REGEX.exec(parsedImport[2]);
+        if (namedImportsMatch) {
+          namedImportsMatch[1].split(',').forEach((importName) => {
+            namedImports.push(importName.trim());
+          });
+        }
+      }
+
+      return {
+        moduleUrl: entry.path,
+        defaultImport: !!parsedImport?.[1],
+        namedImports,
+      };
+    });
+  }
+
+  analyzeSourceFileImports(code: string) {
+    // TODO(dmaretskyi): Support import aliases and wildcard imports.
+    const parsedImports = allMatches(IMPORT_REGEX, code);
+    return parsedImports.map((capture) => {
+      return {
+        defaultImportName: capture[1],
+        namedImports: capture[2]?.split(',').map((importName) => importName.trim()),
+        wildcardImportName: capture[3],
+        moduleIdentifier: capture[4],
+        quotes: capture[5],
+      };
+    });
+  }
+}
+
+// https://regex101.com/r/FEN5ks/1
+// https://stackoverflow.com/a/73265022
+// $1 = default import name (can be non-existent)
+// $2 = destructured exports (can be non-existent)
+// $3 = wildcard import name (can be non-existent)
+// $4 = module identifier
+// $5 = quotes used (either ' or ")
+const IMPORT_REGEX =
+  /import(?:(?:(?:[ \n\t]+([^ *\n\t{},]+)[ \n\t]*(?:,|[ \n\t]+))?([ \n\t]*{(?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+})?[ \n\t]*)|[ \n\t]*\*[ \n\t]*as[ \n\t]+([^ \n\t{}]+)[ \n\t]+)from[ \n\t]*(?:['"])([^'"\n]+)(['"])/gm;
+
+const NAMED_IMPORTS_REGEX = /[ \n\t]*{((?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+)}[ \n\t]*/gm;
+
+const allMatches = (regex: RegExp, str: string) => {
+  regex.lastIndex = 0;
+
+  let match;
+  const matches = [];
+  while ((match = regex.exec(str))) {
+    matches.push(match);
+  }
+
+  return matches;
+};
+
+type ParsedImport = {
+  defaultImportName?: string;
+  namedImports: string[];
+  wildcardImportName?: string;
+  moduleIdentifier: string;
+  quotes: string;
+};
+
+const analyzeSourceFileImports = (code: string): ParsedImport[] => {
+  // TODO(dmaretskyi): Support import aliases and wildcard imports.
+  const parsedImports = allMatches(IMPORT_REGEX, code);
+  return parsedImports.map((capture) => {
+    return {
+      defaultImportName: capture[1],
+      namedImports: capture[2]
+        ?.trim()
+        .slice(1, -1)
+        .split(',')
+        .map((importName) => importName.trim()),
+      wildcardImportName: capture[3],
+      moduleIdentifier: capture[4],
+      quotes: capture[5],
+    };
+  });
+};
+
+const httpPlugin: Plugin = {
+  name: 'http',
+  setup: (build) => {
+    // Intercept import paths starting with "http:" and "https:" so esbuild doesn't attempt to map them to a file system location.
+    // Tag them with the "http-url" namespace to associate them with this plugin.
+    build.onResolve({ filter: /^https?:\/\// }, (args) => ({
+      path: args.path,
+      namespace: 'http-url',
+    }));
+
+    // We also want to intercept all import paths inside downloaded files and resolve them against the original URL.
+    // All of these files will be in the "http-url" namespace.
+    // Make sure to keep the newly resolved URL in the "http-url" namespace so imports inside it will also be resolved as URLs recursively.
+    build.onResolve({ filter: /.*/, namespace: 'http-url' }, (args) => ({
+      path: new URL(args.path, args.importer).toString(),
+      namespace: 'http-url',
+    }));
+
+    // When a URL is loaded, we want to actually download the content from the internet.
+    // This has just enough logic to be able to handle the example import from unpkg.com but in reality this would probably need to be more complex.
+    build.onLoad({ filter: /.*/, namespace: 'http-url' }, async (args) => {
+      const response = await fetch(args.path);
+      return { contents: await response.text(), loader: 'jsx' };
+    });
+  },
+};

package/src/bundler/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export * from './bundler';

package/src/handler.ts

@@ -2,13 +2,17 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type Schema as S } from '@effect/schema';
+import { Schema as S } from '@effect/schema';
+import { type Effect } from 'effect';
 
 import { type Client, PublicKey } from '@dxos/client';
 import { type Space, type SpaceId } from '@dxos/client/echo';
-import type { CoreDatabase, ReactiveEchoObject } from '@dxos/echo-db';
+import type { CoreDatabase, EchoDatabase, ReactiveEchoObject } from '@dxos/echo-db';
+import { type HasId } from '@dxos/echo-schema';
+import { type DXN } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { nonNullable } from '@dxos/util';
+import { type QueryResult } from '@dxos/protocols';
+import { isNonNullable } from '@dxos/util';
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
@@ -18,15 +22,14 @@ import { nonNullable } from '@dxos/util';
 /**
  * Function handler.
  */
-export type FunctionHandler<TData = {}, TMeta = {}> = (params: {
+export type FunctionHandler<TData = {}, TMeta = {}, TOutput = any> = (params: {
   context: FunctionContext;
   event: FunctionEvent<TData, TMeta>;
-
   /**
    * @deprecated
    */
   response: FunctionResponse;
-}) => Promise<Response | FunctionResponse | void>;
+}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any>;
 
 /**
  * Function context.
@@ -84,17 +87,61 @@ export type FunctionResponse = {
 // API.
 //
 
+// TODO(dmaretskyi): Temporary API to get the queues working.
+// TODO(dmaretskyi): To be replaced with integrating queues into echo.
+export interface QueuesAPI {
+  queryQueue(queue: DXN, options?: {}): Promise<QueryResult>;
+  insertIntoQueue(queue: DXN, objects: HasId[]): Promise<void>;
+}
+
 /**
  * Space interface available to functions.
  */
 export interface SpaceAPI {
   get id(): SpaceId;
+  /**
+   * @deprecated
+   */
   get crud(): CoreDatabase;
+  get db(): EchoDatabase;
+  // TODO(dmaretskyi): Align with echo api --- queues.get(id).append(items);
+  get queues(): QueuesAPI;
 }
 
+// TODO(wittjosiah): Fix this.
 const __assertFunctionSpaceIsCompatibleWithTheClientSpace = () => {
-  // eslint-disable-next-line unused-imports/no-unused-vars
-  const y: SpaceAPI = {} as Space;
+  // const _: SpaceAPI = {} as Space;
+};
+
+export type FunctionDefinition = {
+  description?: string;
+  inputSchema: S.Schema.AnyNoContext;
+  outputSchema?: S.Schema.AnyNoContext;
+  handler: FunctionHandler<any>;
+};
+
+export type DefineFunctionParams<T, O = any> = {
+  description?: string;
+  inputSchema: S.Schema<T, any>;
+  outputSchema?: S.Schema<O, any>;
+  handler: FunctionHandler<T, any, O>;
+};
+
+// TODO(dmaretskyi): Bind input type to function handler.
+export const defineFunction = <T, O>(params: DefineFunctionParams<T, O>): FunctionDefinition => {
+  if (!S.isSchema(params.inputSchema)) {
+    throw new Error('Input schema must be a valid schema');
+  }
+  if (typeof params.handler !== 'function') {
+    throw new Error('Handler must be a function');
+  }
+
+  return {
+    description: params.description,
+    inputSchema: params.inputSchema,
+    outputSchema: params.outputSchema ?? S.Any,
+    handler: params.handler,
+  };
 };
 
 //
@@ -136,7 +183,9 @@ export const subscriptionHandler = <TMeta>(
 
     registerTypes(space, types);
     const objects = space
-      ? data.objects?.map<ReactiveEchoObject<any> | undefined>((id) => space!.db.getObjectById(id)).filter(nonNullable)
+      ? data.objects
+          ?.map<ReactiveEchoObject<any> | undefined>((id) => space!.db.getObjectById(id))
+          .filter(isNonNullable)
       : [];
 
     if (!!data.spaceKey && !space) {