@dxos/edge-compute 0.0.0

package/src/bundler/bundler.ts

@@ -0,0 +1,232 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type BuildResult, type Plugin, type PluginBuild, build, initialize } from 'esbuild-wasm';
+
+import { subtleCrypto } from '@dxos/crypto';
+import { invariant } from '@dxos/invariant';
+import { isNode, trim } from '@dxos/util';
+
+import { httpPlugin } from './plugins/http-plugin-esbuild';
+import { PluginR2VendoredPackages } from './plugins/r2-vendored-packages';
+
+export type Import = {
+  moduleUrl: string;
+  defaultImport: boolean;
+  namedImports: string[];
+};
+
+export type BundleOptions = {
+  /**
+   * Source code to bundle.
+   */
+  source: string;
+};
+
+export type BundleResult =
+  | {
+      timestamp: number;
+      sourceHash: Buffer;
+      error: unknown;
+    }
+  | {
+      timestamp: number;
+      sourceHash: Buffer;
+      imports: Import[];
+      entryPoint: string;
+      assets: Record<string, Uint8Array>;
+    };
+
+let initialized: Promise<void>;
+/**
+ * Initializes the bundler.
+ * Must be called before using the bundler in browser.
+ */
+export const initializeBundler = async (options: { wasmUrl: string }) => {
+  await (initialized ??= initialize({
+    wasmURL: options.wasmUrl,
+  }));
+};
+
+/**
+ * ESBuild bundler implemented as a function (parity with native bundler API style).
+ * Bundles source code directly, does not really on filesystem or Node APIs.
+ *
+ * This is browser friendly version of the bundler, but it could also be used in Node environment.
+ * `initializeBundler` should be called before using it in browser, not required in Node.
+ */
+export const bundleFunction = async ({ source }: BundleOptions): Promise<BundleResult> => {
+  const sourceHash = Buffer.from(await subtleCrypto.digest('SHA-256', Buffer.from(source)));
+
+  if (!isNode()) {
+    invariant(initialized, 'Compiler not initialized.');
+    await initialized;
+  }
+  const outdir = '/tmp/bundle';
+  try {
+    const result = await build({
+      platform: 'browser',
+      conditions: ['workerd', 'worker', 'browser'],
+      metafile: true,
+      write: false,
+      entryPoints: {
+        // Keep output name stable as `index.js` to preserve API.
+        index: 'dxos:entrypoint',
+      },
+      outdir,
+      bundle: true,
+
+      // NOTE: Splitting causes an error in Cloudflare-Workers:
+      //   Disallowed operation called within global scope.
+      //   Asynchronous I/O (ex: fetch() or connect()), setting a timeout, and generating random values are not allowed within global scope.
+      //   To fix this error, perform this operation within a handler. https://developers.cloudflare.com/workers/runtime-apis/handlers/
+      //
+      // Likely, workerd is treating asynchronously-loaded modules as if they were executing in global scope.
+      // splitting: true,
+      format: 'esm',
+      target: 'esnext',
+      supported: {
+        'class-private-accessor': true,
+        'class-private-brand-check': true,
+        'class-private-field': true,
+        'class-private-method': true,
+        'class-private-static-accessor': true,
+        'class-private-static-field': true,
+        'class-private-static-method': true,
+      },
+      external: ['cloudflare:workers'],
+      alias: {
+        'node:path': 'path',
+      },
+      plugins: [
+        httpPlugin as any as Plugin,
+        {
+          // Provide a virtual entrypoint that wraps the user handler similar to the native bundler.
+          name: 'entrypoint',
+          setup: (build: PluginBuild) => {
+            build.onResolve({ filter: /^dxos:entrypoint$/ }, () => ({
+              path: 'dxos:entrypoint',
+              namespace: 'dxos:entrypoint',
+            }));
+            // TODO(dmaretskyi): Move into memory plugin
+            build.onLoad({ filter: /^dxos:entrypoint$/, namespace: 'dxos:entrypoint' }, () => {
+              return {
+                contents: trim`
+                  export default {
+                    fetch: async (...args) => {
+                      const { wrapFunctionHandler } = await import('@dxos/compute-runtime');
+                      const { wrapHandlerForCloudflare } = await import('@dxos/functions-runtime-cloudflare');
+                      const { default: handler } = await import('memory:source.tsx');
+
+                      //
+                      // Wrapper to make the function cloudflare-compatible.
+                      //
+                      return wrapHandlerForCloudflare(wrapFunctionHandler(handler))(...args);
+                    },
+                  };
+                `,
+                loader: 'ts',
+              } as const;
+            });
+          },
+        },
+        {
+          name: 'memory',
+          setup: (build) => {
+            build.onResolve({ filter: /^memory:/ }, ({ path }) => {
+              return { path: path.split(':')[1], namespace: 'memory' };
+            });
+
+            build.onLoad({ filter: /.*/, namespace: 'memory' }, ({ path }) => {
+              switch (path) {
+                case 'source.tsx':
+                  return {
+                    contents: source,
+                    loader: 'tsx',
+                  };
+                case 'empty':
+                  return {
+                    contents: '',
+                    loader: 'js',
+                  };
+              }
+            });
+          },
+        },
+        // PluginESMSh(),
+        PluginR2VendoredPackages(),
+      ],
+    });
+
+    // log.info('Bundling complete', result.metafile);
+    // log.info('Output files', { files: result.outputFiles });
+
+    const entryPoint = 'index.js';
+    return {
+      timestamp: Date.now(),
+      sourceHash,
+      imports: analyzeImports(result),
+      entryPoint,
+      assets: result.outputFiles.reduce(
+        (acc, file) => {
+          acc[file.path.replace(outdir + '/', '')] = file.contents;
+          return acc;
+        },
+        {} as Record<string, Uint8Array>,
+      ),
+    };
+  } catch (err) {
+    return { timestamp: Date.now(), sourceHash, error: err };
+  }
+};
+
+// TODO(dmaretskyi): In the future we can replace the compiler with SWC with plugins running in WASM.
+const 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,
+    };
+  });
+};
+
+// 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) => {
+  let match;
+  const matches = [];
+  regex.lastIndex = 0;
+  while ((match = regex.exec(str))) {
+    matches.push(match);
+  }
+
+  return matches;
+};

package/src/bundler/index.ts

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

package/src/bundler/plugins/embedded-vendored-packages.ts

@@ -0,0 +1,39 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Function from 'effect/Function';
+import * as Record from 'effect/Record';
+import type { Plugin } from 'esbuild-wasm';
+
+// TODO(dmaretskyi): Haven't managed to get this working.
+export const PluginEmbeddedVendoredPackages = (): Plugin => ({
+  name: 'embedded-vendored-packages',
+  setup: (build) => {
+    // // https://vite.dev/guide/features#custom-queries
+    const moduleUrls = Function.pipe(
+      // NOTE: Vite-specific API.
+      // @ts-expect-error
+      import.meta.glob('../../dist/vendor/**/*.js', {
+        query: '?url',
+        import: 'default',
+        eager: true,
+      }) as Record<string, string>,
+      Record.mapKeys((s) => s.replace('../../dist/vendor/', '').replace(/\.js$/, '')),
+      Record.filter((_, key) => !key.startsWith('internal/')),
+    );
+
+    // console.log(moduleUrls);
+
+    build.onResolve({ filter: /^[^./]/ }, (args) => {
+      if (args.kind === 'entry-point') {
+        return;
+      }
+
+      return build.resolve(new URL(moduleUrls[args.path], import.meta.url).href, {
+        kind: args.kind,
+        resolveDir: args.resolveDir,
+      });
+    });
+  },
+});

package/src/bundler/plugins/http-plugin-esbuild.ts

@@ -0,0 +1,77 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Schedule from 'effect/Schedule';
+import { type Loader, type Plugin } from 'esbuild';
+
+import { EffectEx } from '@dxos/effect';
+import { BaseError } from '@dxos/errors';
+
+const MAX_RETRIES = 5;
+const INITIAL_DELAY = 1_000;
+
+export class HttpPluginError extends BaseError.extend('HttpPluginError') {}
+
+const LOADERS: Record<string, Loader> = {
+  js: 'js',
+  jsx: 'jsx',
+  ts: 'ts',
+  tsx: 'tsx',
+  wasm: 'copy',
+} as const;
+
+export 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) => {
+      return Effect.gen(function* () {
+        const response = yield* HttpClient.get(args.path);
+        if (response.status !== 200) {
+          yield* Effect.fail(
+            new HttpPluginError({
+              message: `failed to fetch ${args.path}, status: ${response.status}`,
+            }),
+          );
+        }
+
+        const contents = new Uint8Array(yield* response.arrayBuffer);
+        const extension = new URL(args.path).pathname.split('.').pop() || '';
+        const loader = LOADERS[extension.toLowerCase()] ?? 'jsx';
+        return { contents, loader };
+      }).pipe(
+        Effect.retry(
+          Function.pipe(
+            Schedule.exponential(Duration.millis(INITIAL_DELAY)),
+            Schedule.jittered,
+            Schedule.intersect(Schedule.recurs(MAX_RETRIES - 1)),
+          ),
+        ),
+        Effect.provide(FetchHttpClient.layer),
+        EffectEx.runAndForwardErrors,
+      );
+    });
+  },
+};

package/src/bundler/plugins/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './http-plugin-esbuild';
+export * from './r2-vendored-packages';
+export * from './embedded-vendored-packages';

package/src/bundler/plugins/r2-vendored-packages.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type { Plugin } from 'esbuild-wasm';
+
+/*
+
+script-vendored-packages bucket on R2
+
+https://dash.cloudflare.com/950816f3f59b079880a1ae33fb0ec320/r2/default/buckets/script-vendored-packages/settings
+
+'https://pub-5745ae82e450484aa28f75fc6a175935.r2.dev/dev' -- last portion is the env
+
+ 
+*/
+
+const DEFAULT_SCRIPT_PACKAGES_BUCKET = 'https://pub-5745ae82e450484aa28f75fc6a175935.r2.dev/dev/';
+
+export const PluginR2VendoredPackages = ({ url = DEFAULT_SCRIPT_PACKAGES_BUCKET }: { url?: string } = {}): Plugin => ({
+  name: 'r2-vendored-packages',
+  setup: (build) => {
+    build.onResolve({ filter: /^[^./]/ }, (args) => {
+      if (args.kind === 'entry-point') {
+        return;
+      }
+
+      return {
+        // NOTE: Use .js extension for tsdown
+        path: new URL(`${args.path}.js`, url).href,
+        namespace: 'http-url', // Uses http plugin.
+      };
+    });
+  },
+});

package/src/edge-client.ts

@@ -0,0 +1,156 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Array from 'effect/Array';
+import * as Function$ from 'effect/Function';
+import * as Order from 'effect/Order';
+import { type DID } from 'iso-did/types';
+
+import { type Client } from '@dxos/client';
+import { createEdgeIdentity } from '@dxos/client/edge';
+import { Operation } from '@dxos/compute';
+import { FUNCTIONS_META_KEY, setUserFunctionIdInMetadata } from '@dxos/compute-runtime';
+import { Context } from '@dxos/context';
+import { Obj } from '@dxos/echo';
+import { EdgeHttpClient } from '@dxos/edge-client';
+import { invariant } from '@dxos/invariant';
+import { type PublicKey, type SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { type UploadFunctionResponseBody } from '@dxos/protocols';
+import { safeParseJson } from '@dxos/util';
+
+/** @deprecated Use {@link FunctionsServiceClient} instead. */
+export type UploadWorkerArgs = {
+  client: Client;
+  version: string;
+  name?: string;
+  functionId?: string;
+  /** Owner identity DID (`did:halo:…`). */
+  ownerUri: string;
+  entryPoint: string;
+  assets: Record<string, Uint8Array>;
+};
+
+/** @deprecated Migrate to `client.edge`. */
+export const createEdgeClient = (client: Client): EdgeHttpClient => {
+  const edgeUrl = client.config.values.runtime?.services?.edge?.url;
+  invariant(edgeUrl, 'Edge is not configured.');
+  const edgeClient = new EdgeHttpClient(edgeUrl);
+  const edgeIdentity = createEdgeIdentity(client);
+  edgeClient.setIdentity(edgeIdentity);
+  return edgeClient;
+};
+
+/**
+ * @deprecated Use {@link FunctionsServiceClient} instead.
+ */
+export const uploadWorkerFunction = async (
+  ctx: Context,
+  { client, version, name, functionId, ownerUri, entryPoint, assets }: UploadWorkerArgs,
+): Promise<UploadFunctionResponseBody> => {
+  log('uploading function', { functionId, name, version, ownerUri });
+  const edgeClient = createEdgeClient(client);
+  const response = await edgeClient.uploadFunction(
+    ctx,
+    { functionId },
+    { name, version, ownerUri, entryPoint, assets },
+  );
+
+  // TODO(burdon): Edge service log.
+  log('uploaded', {
+    identityKey: client.halo.identity.get()?.identityKey,
+    did: client.halo.identity.get()?.did,
+    functionId,
+    name,
+    version,
+    response,
+  });
+
+  return response;
+};
+
+/**
+ * @deprecated Use {@link FunctionsServiceClient} instead.
+ */
+export const getDeployedFunctions = async (
+  ctx: Context,
+  client: Client,
+  dedupe = false,
+): Promise<Operation.PersistentOperation[]> => {
+  const edgeClient = createEdgeClient(client);
+  const result = await edgeClient.listFunctions(ctx);
+  const functions: Operation.PersistentOperation[] = result.uploadedFunctions.flatMap((record: any) => {
+    // Record shape is determined by EDGE API. We defensively parse.
+    const latest = record.latestVersion ?? {};
+    const versionMeta = safeParseJson<any>(latest.versionMetaJSON);
+    if (!versionMeta) {
+      return [];
+    }
+    const fn = Obj.make(Operation.PersistentOperation, {
+      [Obj.Meta]: {
+        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,
+    });
+
+    Obj.update(fn, (fn) => setUserFunctionIdInMetadata(Obj.getMeta(fn), record.id));
+    return [fn];
+  });
+
+  if (dedupe) {
+    return Function$.pipe(
+      functions,
+      Array.filter((_) => Obj.getMeta(_).key !== undefined),
+      Array.sort(Order.reverse(Order.mapInput(Order.string, (_: Operation.PersistentOperation) => _.updated ?? ''))),
+      Array.dedupeWith((self, that) => Obj.getMeta(self).key === Obj.getMeta(that).key),
+      Array.sort(Order.mapInput(Order.string, (_: Operation.PersistentOperation) => Obj.getMeta(_).key ?? '')),
+    );
+  } else {
+    return functions;
+  }
+};
+
+/**
+ * @deprecated Use {@link FunctionsServiceClient} instead.
+ */
+export const invokeFunction = async (
+  ctx: Context,
+  edgeClient: EdgeHttpClient,
+  fn: Operation.PersistentOperation,
+  input: unknown,
+  {
+    spaceId,
+    cpuTimeLimit,
+    subrequestsLimit,
+  }: { spaceId?: SpaceId; cpuTimeLimit?: number; subrequestsLimit?: number } = {},
+) => {
+  const functionId = Obj.getMeta(fn).keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
+  if (!functionId) {
+    throw new Error('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(/^\//, '');
+  return await edgeClient.invokeFunction(
+    ctx,
+    { functionId: cleanedId, spaceId, cpuTimeLimit, subrequestsLimit },
+    input,
+  );
+};
+
+export const incrementSemverPatch = (version: string): string => {
+  const [major, minor, patch] = version.split('.');
+  const patchNum = Number(patch);
+  invariant(!Number.isNaN(patchNum), `Unexpected function version format: ${version}`);
+  return [major, minor, String(patchNum + 1)].join('.');
+};
+
+// TODO(burdon): Factor out.
+export const publicKeyToDid = (key: PublicKey): DID => {
+  return `did:key:${key.toHex()}`;
+};

package/src/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export * from './edge-client';
+export * as EdgeOperationInvoker from './EdgeOperationInvoker';
+export * as EdgeProcessManager from './EdgeProcessManager';
+export * as EdgeTriggerManager from './EdgeTriggerManager';
+export * from './FunctionsServiceClient';