@dxos/edge-compute 0.0.0

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@dxos/edge-compute",
+  "version": "0.0.0",
+  "description": "EDGE compute: function deploy, scripts, and Edge implementations of Remote* runtime interfaces.",
+  "homepage": "https://dxos.org",
+  "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
+  "license": "FSL-1.1-Apache-2.0",
+  "author": "info@dxos.org",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/types/src/index.d.ts",
+      "default": "./dist/lib/neutral/index.mjs"
+    },
+    "./testing": {
+      "source": "./src/testing/index.ts",
+      "types": "./dist/types/src/testing/index.d.ts",
+      "default": "./dist/lib/neutral/testing/index.mjs"
+    },
+    "./bundler": {
+      "source": "./src/bundler/index.ts",
+      "types": "./dist/types/src/bundler/index.d.ts",
+      "default": "./dist/lib/neutral/bundler/index.mjs"
+    },
+    "./native": {
+      "source": "./src/native/index.ts",
+      "types": "./dist/types/src/native/index.d.ts",
+      "default": "./dist/lib/neutral/native/index.mjs"
+    }
+  },
+  "types": "dist/types/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "testing": [
+        "dist/types/src/testing/index.d.ts"
+      ],
+      "bundler": [
+        "dist/types/src/bundler/index.d.ts"
+      ],
+      "native": [
+        "dist/types/src/native/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist/lib",
+    "dist/types",
+    "src"
+  ],
+  "dependencies": {
+    "@effect-atom/atom": "^0.5.3",
+    "@effect/platform": "0.96.2",
+    "effect": "3.21.4",
+    "esbuild": "0.28.1",
+    "esbuild-wasm": "^0.28.0",
+    "iso-did": "^1.6.0",
+    "@dxos/client": "0.10.0",
+    "@dxos/compute-runtime": "0.10.0",
+    "@dxos/echo": "0.10.0",
+    "@dxos/context": "0.10.0",
+    "@dxos/compute": "0.10.0",
+    "@dxos/crypto": "0.10.0",
+    "@dxos/echo-client": "0.10.0",
+    "@dxos/edge-client": "0.10.0",
+    "@dxos/effect": "0.10.0",
+    "@dxos/errors": "0.10.0",
+    "@dxos/functions-runtime-cloudflare": "0.10.0",
+    "@dxos/invariant": "0.10.0",
+    "@dxos/keys": "0.10.0",
+    "@dxos/node-std": "0.10.0",
+    "@dxos/util": "0.10.0",
+    "@dxos/protocols": "0.10.0",
+    "@dxos/log": "0.10.0"
+  },
+  "devDependencies": {
+    "@effect/vitest": "0.29.0",
+    "vitest": "4.1.10"
+  },
+  "peerDependencies": {
+    "effect": "3.21.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "publish-runtime": "pnpm run secrets && node ./scripts/build-modules.mjs && node --env-file=.env ./scripts/upload-modules.mjs --env dev",
+    "secrets": "node ./scripts/secrets.mjs"
+  }
+}

package/src/EdgeOperationInvoker.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { type Client, ClientService } from '@dxos/client';
+import { FunctionError } from '@dxos/compute';
+import { RemoteOperationInvoker } from '@dxos/compute-runtime';
+import { type Context as DxosContext } from '@dxos/context';
+import { type SpaceId } from '@dxos/keys';
+
+import { createEdgeClient } from './edge-client';
+
+type EdgeClient = ReturnType<typeof createEdgeClient>;
+
+const make = (getEdgeClient: () => EdgeClient, spaceId?: SpaceId): RemoteOperationInvoker.Invoker => ({
+  invoke: <I, O>(ctx: DxosContext, deployedId: string, input: I): Effect.Effect<O> =>
+    Effect.gen(function* () {
+      const cleanedId = deployedId.replace(/^\//, '');
+      return yield* Effect.promise(() =>
+        getEdgeClient().invokeFunction(ctx, { functionId: cleanedId, spaceId }, input),
+      ).pipe(Effect.mapError(FunctionError.wrap()), Effect.orDie);
+    }),
+});
+
+/**
+ * For tests: provide a pre-built edge client.
+ */
+export const fromEdgeClient = (
+  edgeClient: EdgeClient,
+  spaceId?: SpaceId,
+): Layer.Layer<RemoteOperationInvoker.Service> =>
+  Layer.succeed(
+    RemoteOperationInvoker.Service,
+    make(() => edgeClient, spaceId),
+  );
+
+/**
+ * Build from a `Client`, deferring edge-client creation until first invoke
+ * (identity may be absent at boot).
+ */
+export const fromClient = (client: Client, spaceId?: SpaceId): Layer.Layer<RemoteOperationInvoker.Service> => {
+  let cached: EdgeClient | undefined;
+  return Layer.succeed(
+    RemoteOperationInvoker.Service,
+    make(() => (cached ??= createEdgeClient(client)), spaceId),
+  );
+};
+
+/**
+ * Build from the ambient `ClientService`.
+ */
+export const layer = (spaceId?: SpaceId): Layer.Layer<RemoteOperationInvoker.Service, never, ClientService> =>
+  Layer.effect(
+    RemoteOperationInvoker.Service,
+    Effect.gen(function* () {
+      const client = yield* ClientService;
+      let cached: EdgeClient | undefined;
+      return make(() => (cached ??= createEdgeClient(client)), spaceId);
+    }),
+  );

package/src/EdgeProcessManager.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import { Atom, Registry } from '@effect-atom/atom';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { type Client } from '@dxos/client';
+import { type Process } from '@dxos/compute';
+import { RemoteProcessManager } from '@dxos/compute-runtime';
+
+/**
+ * EDGE implementation of {@link RemoteProcessManager.Service}.
+ *
+ * The EDGE worker exposes no process-tree endpoint yet (see Decision D3), so
+ * this currently returns an empty tree. Once an endpoint lands, poll it into
+ * `processTreeAtom` here.
+ */
+const make = (): Layer.Layer<RemoteProcessManager.Service, never, Registry.AtomRegistry> =>
+  Layer.effect(
+    RemoteProcessManager.Service,
+    Effect.gen(function* () {
+      const registry = yield* Registry.AtomRegistry;
+      // TODO(edge): Populate from an EDGE process-tree endpoint once available.
+      const processTreeAtom = Atom.make<readonly Process.Info[]>([]);
+      registry.mount(processTreeAtom);
+      return {
+        processTree: Effect.sync(() => registry.get(processTreeAtom)),
+        processTreeAtom,
+      } satisfies RemoteProcessManager.Manager;
+    }),
+  );
+
+/**
+ * Build from a `Client`. Currently ignores the client until an EDGE
+ * process-tree endpoint exists.
+ */
+export const fromClient = (_client: Client): Layer.Layer<RemoteProcessManager.Service, never, Registry.AtomRegistry> =>
+  make();
+
+/**
+ * Empty EDGE process manager (no endpoint yet).
+ */
+export const layer: Layer.Layer<RemoteProcessManager.Service, never, Registry.AtomRegistry> = make();

package/src/EdgeTriggerManager.ts

@@ -0,0 +1,70 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import { Atom, Registry } from '@effect-atom/atom';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { type Client, ClientService } from '@dxos/client';
+import { type Trigger } from '@dxos/compute';
+import { RemoteTriggerManager } from '@dxos/compute-runtime';
+import { type SpaceId } from '@dxos/keys';
+
+/**
+ * EDGE implementation of {@link RemoteTriggerManager.Service}.
+ *
+ * Edge triggers are ECHO objects replicated into the local database, so the
+ * aggregate {@link TriggerMonitor} already surfaces them (marked
+ * `environment: 'edge'`) from that database view; the `triggers` atom here is
+ * therefore left empty to avoid double-counting. It exists as the seam through
+ * which EDGE dispatcher runtime status can be layered in once a mapping to
+ * {@link Trigger.State} is available.
+ *
+ * `invokeTrigger` is not yet supported over the wire (edge triggers run
+ * autonomously on the EDGE dispatcher).
+ */
+const make = (_spaceId?: SpaceId): Layer.Layer<RemoteTriggerManager.Service, never, Registry.AtomRegistry> =>
+  Layer.effect(
+    RemoteTriggerManager.Service,
+    Effect.gen(function* () {
+      const registry = yield* Registry.AtomRegistry;
+      // TODO(edge): Poll `EdgeHttpClient.getTriggersDispatcherStatus` and enrich edge trigger state here.
+      const triggers = Atom.make<readonly Trigger.State[]>([]);
+      registry.mount(triggers);
+      return {
+        triggers,
+        invokeTrigger: () => Effect.die(new Error('Remote (EDGE) trigger invocation is not supported')),
+      } satisfies RemoteTriggerManager.Manager;
+    }),
+  );
+
+/**
+ * Build from a `Client`.
+ */
+export const fromClient = (
+  _client: Client,
+  spaceId?: SpaceId,
+): Layer.Layer<RemoteTriggerManager.Service, never, Registry.AtomRegistry> => make(spaceId);
+
+/**
+ * Build from the ambient `ClientService`.
+ */
+export const layer = (
+  spaceId?: SpaceId,
+): Layer.Layer<RemoteTriggerManager.Service, never, Registry.AtomRegistry | ClientService> =>
+  Layer.effect(
+    RemoteTriggerManager.Service,
+    Effect.gen(function* () {
+      yield* ClientService;
+      const registry = yield* Registry.AtomRegistry;
+      const triggers = Atom.make<readonly Trigger.State[]>([]);
+      registry.mount(triggers);
+      return {
+        triggers,
+        invokeTrigger: () => Effect.die(new Error('Remote (EDGE) trigger invocation is not supported')),
+      } satisfies RemoteTriggerManager.Manager;
+    }),
+  );

package/src/FunctionsServiceClient.ts

@@ -0,0 +1,189 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Client } from '@dxos/client';
+import { FunctionError, Operation } from '@dxos/compute';
+import { FUNCTIONS_META_KEY } from '@dxos/compute-runtime';
+import { FunctionServiceError } from '@dxos/compute-runtime';
+import { type Context } from '@dxos/context';
+import { Obj } from '@dxos/echo';
+import { type EdgeHttpClient, type TriggersDispatcherStatus } from '@dxos/edge-client';
+import { invariant } from '@dxos/invariant';
+import { type EntityId, type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { type FunctionRuntimeKind, type SerializedError } from '@dxos/protocols';
+import { safeParseJson } from '@dxos/util';
+
+import { createEdgeClient } from './edge-client';
+
+// TODO(wittjosiah): Copied from @dxos/functions-simulator-cloudflare.
+export type InvokeResult =
+  | {
+      _kind: 'success';
+      /**
+       * The output of the function.
+       */
+      result: unknown;
+    }
+  | {
+      _kind: 'error';
+      error: SerializedError;
+    };
+
+export type FunctionDeployOptions = {
+  name?: string;
+  version: string;
+
+  /** Service-side function id in case this function is a re-upload of a previous version. */
+  functionId?: string;
+
+  /** Owner identity DID (`did:halo:…`). Must equal the authenticated presenter DID. */
+  ownerUri: string;
+
+  runtime?: FunctionRuntimeKind;
+
+  /** Path of the entry point file in the assets table. */
+  entryPoint: string;
+
+  assets: {
+    // TODO(dmaretskyi): Allow passing strings and setting mime-type.
+    [path: string]: Uint8Array;
+  };
+};
+
+export type FunctionInvokeOptions = {
+  /**
+   * Space in which the function is invoked.
+   * Binds the Database.Service injected into the function to this space.
+   * Without this, the function will not have access to any database.
+   */
+  spaceId?: SpaceId;
+
+  /**
+   * CPU time limit in milliseconds.
+   * See Cloudflare docs for details.
+   */
+  cpuTimeLimit?: number;
+
+  /**
+   * Maximum number of subrequests.
+   * See Cloudflare docs for details.
+   */
+  subrequestsLimit?: number;
+};
+
+export class FunctionsServiceClient {
+  static fromClient(client: Client) {
+    return new FunctionsServiceClient(createEdgeClient(client));
+  }
+
+  #edgeClient: EdgeHttpClient;
+
+  constructor(edgeClient: EdgeHttpClient) {
+    this.#edgeClient = edgeClient;
+  }
+
+  /**
+   * Deploys a function to the EDGE service.
+   */
+  async deploy(ctx: Context, request: FunctionDeployOptions): Promise<Operation.PersistentOperation> {
+    try {
+      invariant(
+        Object.keys(request.assets).every((path) => !path.startsWith('/')),
+        'Asset paths must be relative',
+      );
+      const response = await this.#edgeClient.uploadFunction(
+        ctx,
+        { functionId: request.functionId },
+        {
+          name: request.name,
+          version: request.version,
+          ownerUri: request.ownerUri,
+          entryPoint: request.entryPoint,
+          assets: request.assets,
+          runtime: request.runtime,
+        },
+        { retry: { count: 3 }, auth: true },
+      );
+      log.verbose('deploy result', { ...response });
+
+      return Obj.make(Operation.PersistentOperation, {
+        [Obj.Meta]: {
+          keys: [{ source: FUNCTIONS_META_KEY, id: response.functionId }],
+          key: response.meta.key,
+          version: response.version,
+        },
+        name: response.meta.name ?? 'Unnamed function',
+        description: response.meta.description,
+        inputSchema: response.meta.inputSchema,
+        outputSchema: response.meta.outputSchema,
+      });
+    } catch (error) {
+      throw FunctionServiceError.wrap({ message: 'Failed to deploy function', ifTypeDiffers: true })(error);
+    }
+  }
+
+  /**
+   * Queries the EDGE service for deployed functions.
+   */
+  // TODO(dmaretskyi): Add query filters.
+  async query(ctx: Context): Promise<Operation.PersistentOperation[]> {
+    try {
+      const response = await this.#edgeClient.listFunctions(ctx);
+      return response.uploadedFunctions.flatMap((record: any) => {
+        const latest = record.latestVersion ?? {};
+        const versionMeta = safeParseJson<any>(latest.versionMetaJSON);
+        if (!versionMeta) {
+          return [];
+        }
+        const fn = Obj.make(Operation.PersistentOperation, {
+          [Obj.Meta]: {
+            keys: [{ source: FUNCTIONS_META_KEY, id: record.id }],
+            key: versionMeta.key,
+            version: latest?.version ?? '0.0.0',
+          },
+          name: versionMeta.name ?? versionMeta.key ?? record.id,
+          updated: record?.updated !== undefined ? new Date(record.updated).toISOString() : undefined,
+          description: versionMeta.description,
+          inputSchema: versionMeta.inputSchema,
+          outputSchema: versionMeta.outputSchema,
+        });
+        return [fn];
+      });
+    } catch (error) {
+      throw FunctionServiceError.wrap({ message: 'Failed to query functions', ifTypeDiffers: true })(error);
+    }
+  }
+
+  async invoke(ctx: Context, func: Operation.PersistentOperation, input: unknown, options?: FunctionInvokeOptions) {
+    const functionId = Obj.getMeta(func).keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
+    if (!functionId) {
+      throw new FunctionServiceError({ message: 'No identifier for the function at the EDGE service' });
+    }
+    // COMPAT: Previously functionId was a URL `/<guid>`. Now it's just the `<guid>`.
+    const cleanedId = functionId.replace(/^\//, '');
+    try {
+      return await this.#edgeClient.invokeFunction(
+        ctx,
+        {
+          functionId: cleanedId,
+          spaceId: options?.spaceId,
+          cpuTimeLimit: options?.cpuTimeLimit,
+          subrequestsLimit: options?.subrequestsLimit,
+        },
+        input,
+      );
+    } catch (error) {
+      throw FunctionError.wrap({ message: 'Failed to invoke function', ifTypeDiffers: true })(error);
+    }
+  }
+
+  async forceRunCronTrigger(ctx: Context, spaceId: SpaceId, triggerId: EntityId): Promise<InvokeResult> {
+    return (await this.#edgeClient.forceRunCronTrigger(ctx, spaceId, triggerId)) as InvokeResult;
+  }
+
+  async getTriggersDispatcherStatus(ctx: Context, spaceId: SpaceId): Promise<TriggersDispatcherStatus> {
+    return this.#edgeClient.getTriggersDispatcherStatus(ctx, spaceId);
+  }
+}

package/src/bundler/bundler.test.ts

@@ -0,0 +1,108 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+// @ts-ignore
+import wasmUrl from 'esbuild-wasm/esbuild.wasm?url';
+import { assert, beforeAll, describe, expect, test } from 'vitest';
+
+import { isNode, trim } from '@dxos/util';
+
+import { bundleFunction, initializeBundler } from './bundler';
+
+// SKipped because requies CDN
+describe.skip('Bundler', () => {
+  beforeAll(async () => {
+    if (!isNode()) {
+      await initializeBundler({ wasmUrl });
+    }
+  });
+
+  test('Basic', async () => {
+    const result = await bundleFunction({
+      source: `
+      export default function handler () {
+        return 100;
+      }
+    `,
+    });
+    assert(!('error' in result), 'error should not exist');
+    expect(Object.keys(result.assets)).toBeGreaterThan(1);
+  });
+
+  test('Import', async () => {
+    const result = await bundleFunction({
+      source: `
+      import { Filter } from './runtime.js';
+
+      export default function handler () {
+        return Filter.typename('org.dxos.type.example');
+      }
+    `,
+    });
+    assert(!('error' in result), 'error should not exist');
+    expect(Object.keys(result.assets)).toBeGreaterThan(1);
+  });
+
+  // TODO(dmaretskyi): Flaky on CI.
+  test.skip('HTTPS Import', async () => {
+    const result = await bundleFunction({
+      source: `
+      import { invariant } from 'https://esm.sh/@dxos/invariant';
+      invariant(true);
+    `,
+    });
+    assert(!('error' in result), 'error should not exist');
+    expect(Object.keys(result.assets)).toBeGreaterThan(1);
+  });
+
+  test('Error', async () => {
+    const result = await bundleFunction({
+      source: "import missing from './module'; export default () => missing();",
+    });
+    assert('error' in result, 'error should exist');
+  });
+
+  test('forex-effect', { timeout: 60_000 }, async () => {
+    const result = await bundleFunction({
+      source: trim`
+        //
+        // Copyright 2025 DXOS.org
+        //
+
+        import { defineFunction } from '@dxos/functions';
+        import { FetchHttpClient, HttpClient, HttpClientRequest } from '@effect/platform';
+        import * as Effect from 'effect/Effect';
+        import * as Schedule from 'effect/Schedule';
+        import * as Schema from 'effect/Schema';
+
+        export default defineFunction({
+          key: 'org.dxos.script.forex-effect',
+          name: 'Forex Effect',
+          description: 'Returns the exchange rate between two currencies.',
+
+          inputSchema: Schema.Struct({
+            from: Schema.String.annotations({ description: 'The source currency' }),
+            to: Schema.String.annotations({ description: 'The target currency' }),
+          }),
+
+          outputSchema: Schema.String.annotations({ description: 'The exchange rate between the two currencies' }),
+
+          handler: Effect.fnUntraced(function* ({ data: { from, to } }) {
+            const res = yield* HttpClientRequest.get(\`https://free.ratesdb.com/v1/rates?from=\${from}&to=\${to}\`).pipe(
+              HttpClient.execute,
+              Effect.flatMap((res: any) => res.json),
+              Effect.timeout('1 second'),
+              Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+              Effect.scoped,
+            );
+
+            return (res as any).data.rates[to].toString();
+          }, Effect.provide(FetchHttpClient.layer)),
+        });
+      `,
+    });
+    assert(!('error' in result), 'error should not exist');
+    expect(Object.keys(result.assets)).toBeGreaterThan(1);
+  });
+});