@dxos/edge-compute 0.0.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/edge-compute",
-  "version": "0.0.0",
+  "version": "0.11.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",
@@ -16,22 +16,22 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "default": "./dist/lib/neutral/index.mjs"
+      "import": "./dist/lib/index.mjs"
     },
     "./testing": {
       "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
-      "default": "./dist/lib/neutral/testing/index.mjs"
+      "import": "./dist/lib/testing.mjs"
     },
     "./bundler": {
       "source": "./src/bundler/index.ts",
       "types": "./dist/types/src/bundler/index.d.ts",
-      "default": "./dist/lib/neutral/bundler/index.mjs"
+      "import": "./dist/lib/bundler.mjs"
     },
     "./native": {
       "source": "./src/native/index.ts",
       "types": "./dist/types/src/native/index.d.ts",
-      "default": "./dist/lib/neutral/native/index.mjs"
+      "import": "./dist/lib/native.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -60,23 +60,23 @@
     "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"
+    "@dxos/client": "0.11.0",
+    "@dxos/compute": "0.11.0",
+    "@dxos/compute-runtime": "0.11.0",
+    "@dxos/context": "0.11.0",
+    "@dxos/crypto": "0.11.0",
+    "@dxos/echo": "0.11.0",
+    "@dxos/echo-client": "0.11.0",
+    "@dxos/edge-client": "0.11.0",
+    "@dxos/effect": "0.11.0",
+    "@dxos/errors": "0.11.0",
+    "@dxos/functions-runtime-cloudflare": "0.11.0",
+    "@dxos/invariant": "0.11.0",
+    "@dxos/keys": "0.11.0",
+    "@dxos/log": "0.11.0",
+    "@dxos/node-std": "0.11.0",
+    "@dxos/protocols": "0.11.0",
+    "@dxos/util": "0.11.0"
   },
   "devDependencies": {
     "@effect/vitest": "0.29.0",

package/src/EdgeProcessManager.test.ts

@@ -0,0 +1,59 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Registry } from '@effect-atom/atom';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import { describe, expect, test, vi } from 'vitest';
+
+import { RemoteProcessManager } from '@dxos/compute-runtime';
+import { EdgeHttpClient } from '@dxos/edge-client';
+import { EffectEx } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+import { SpaceId } from '@dxos/keys';
+
+import * as EdgeProcessManager from './EdgeProcessManager';
+
+describe('EdgeProcessManager', () => {
+  test('cancel force-cancels the trigger run on the edge client', async () => {
+    const edgeClient = new EdgeHttpClient('https://edge.example.com');
+    const cancelSpy = vi.spyOn(edgeClient, 'cancelTriggerRun').mockResolvedValue(undefined);
+    const space = SpaceId.random();
+    const trigger = 'TRIGGER1';
+
+    const program = Effect.gen(function* () {
+      const manager = yield* RemoteProcessManager.Service;
+      invariant(manager.cancel, 'edge process manager exposes cancel');
+      yield* manager.cancel({ space, trigger });
+    });
+
+    await EffectEx.runPromise(
+      program.pipe(
+        Effect.provide(EdgeProcessManager.fromEdgeClient(edgeClient)),
+        Effect.provide(Layer.succeed(Registry.AtomRegistry, Registry.make())),
+      ),
+    );
+
+    expect(cancelSpy).toHaveBeenCalledTimes(1);
+    expect(cancelSpy.mock.calls[0]?.[1]).toBe(space);
+    expect(cancelSpy.mock.calls[0]?.[2]).toBe(trigger);
+  });
+
+  test('layer without a client omits cancel and yields an empty tree', async () => {
+    const program = Effect.gen(function* () {
+      const manager = yield* RemoteProcessManager.Service;
+      return { hasCancel: manager.cancel !== undefined, tree: yield* manager.processTree };
+    });
+
+    const result = await EffectEx.runPromise(
+      program.pipe(
+        Effect.provide(EdgeProcessManager.layer),
+        Effect.provide(Layer.succeed(Registry.AtomRegistry, Registry.make())),
+      ),
+    );
+
+    expect(result.hasCancel).toBe(false);
+    expect(result.tree).toEqual([]);
+  });
+});

package/src/EdgeProcessManager.ts

@@ -11,37 +11,86 @@ import * as Layer from 'effect/Layer';
 import { type Client } from '@dxos/client';
 import { type Process } from '@dxos/compute';
 import { RemoteProcessManager } from '@dxos/compute-runtime';
+import { Context as DxosContext } from '@dxos/context';
+import { type EdgeHttpClient } from '@dxos/edge-client';
+import { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+
+import { createEdgeClient } from './edge-client';
 
 /**
  * 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.
+ * The read view (`processTree`) is still empty — the EDGE worker exposes no
+ * process-tree endpoint yet (see Decision D3). What this adds is the `cancel`
+ * control: it force-cancels the current run of an edge trigger (its in-flight
+ * execution and `runAgain` continuation chain) via
+ * {@link EdgeHttpClient.cancelTriggerRun}, addressed by `trigger` in `space`.
+ * A manager built without a client (the {@link layer} stub) omits `cancel`.
  */
-const make = (): Layer.Layer<RemoteProcessManager.Service, never, Registry.AtomRegistry> =>
+const makeManager = (
+  registry: Registry.Registry,
+  getEdgeClient?: () => EdgeHttpClient,
+): RemoteProcessManager.Manager => {
+  // 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,
+    ...(getEdgeClient
+      ? {
+          cancel: ({ space, trigger }: RemoteProcessManager.CancelTarget) =>
+            Effect.gen(function* () {
+              // `space` arrives as an untyped string from trace meta; skip rather than throw when it is
+              // not a valid space id (best-effort — the meter has already cleared locally).
+              if (!SpaceId.isValid(space)) {
+                log.warn('remote trigger cancel skipped: invalid space id', { space });
+                return;
+              }
+              yield* Effect.tryPromise(() =>
+                getEdgeClient().cancelTriggerRun(DxosContext.default(), space, trigger),
+              ).pipe(
+                Effect.asVoid,
+                // A missing/unreachable endpoint (e.g. an older edge deploy) must not surface as a defect
+                // from this fire-and-forget cancel — log and move on.
+                Effect.catchAll((error) => Effect.sync(() => log.warn('remote trigger cancel failed', { error }))),
+              );
+            }),
+        }
+      : {}),
+  } satisfies RemoteProcessManager.Manager;
+};
+
+const make = (
+  getEdgeClient?: () => EdgeHttpClient,
+): 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;
+      return makeManager(registry, getEdgeClient);
     }),
   );
 
 /**
- * Build from a `Client`. Currently ignores the client until an EDGE
- * process-tree endpoint exists.
+ * For tests: provide a pre-built edge client.
+ */
+export const fromEdgeClient = (
+  edgeClient: EdgeHttpClient,
+): Layer.Layer<RemoteProcessManager.Service, never, Registry.AtomRegistry> => make(() => edgeClient);
+
+/**
+ * Build from a `Client`, deferring edge-client creation until the first cancel
+ * (identity / edge config may be absent at boot).
  */
-export const fromClient = (_client: Client): Layer.Layer<RemoteProcessManager.Service, never, Registry.AtomRegistry> =>
-  make();
+export const fromClient = (client: Client): Layer.Layer<RemoteProcessManager.Service, never, Registry.AtomRegistry> => {
+  let cached: EdgeHttpClient | undefined;
+  return make(() => (cached ??= createEdgeClient(client)));
+};
 
 /**
- * Empty EDGE process manager (no endpoint yet).
+ * EDGE process manager with no client — empty process tree and no cancel control.
+ * Used where edge is not configured.
  */
 export const layer: Layer.Layer<RemoteProcessManager.Service, never, Registry.AtomRegistry> = make();

package/src/EdgeTriggerManager.ts

@@ -5,66 +5,140 @@
 // @import-as-namespace
 
 import { Atom, Registry } from '@effect-atom/atom';
+import * as Duration from 'effect/Duration';
 import * as Effect from 'effect/Effect';
+import * as Exit from 'effect/Exit';
 import * as Layer from 'effect/Layer';
+import * as Schedule from 'effect/Schedule';
+import type * as Scope from 'effect/Scope';
 
 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';
+import { Context as DxosContext } from '@dxos/context';
+import { Ref } from '@dxos/echo';
+import { type EdgeTriggerStatus } from '@dxos/edge-client';
+import { EID, type SpaceId } from '@dxos/keys';
+
+import { createEdgeClient } from './edge-client';
+
+type EdgeClient = ReturnType<typeof createEdgeClient>;
+
+/** How often the remote trigger view is refreshed from the EDGE dispatcher. */
+const POLL_INTERVAL = Duration.seconds(15);
 
 /**
  * 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.
+ * The `triggers` atom is populated by polling
+ * {@link EdgeHttpClient.getSpaceTriggers} and mapping each edge trigger's
+ * runtime status into a {@link Trigger.State} (marked `environment: 'edge'`).
+ * The referenced `Trigger` objects are replicated into the local database, so
+ * the trigger ref is a space-relative echo ref synthesized from the id. The
+ * aggregate {@link TriggerMonitor} dedupes these against the database-derived
+ * view (edge entries here supersede the bare database ones).
  *
- * `invokeTrigger` is not yet supported over the wire (edge triggers run
- * autonomously on the EDGE dispatcher).
+ * `invokeTrigger` force-runs the trigger's cron on the EDGE dispatcher via
+ * {@link EdgeHttpClient.forceRunCronTrigger}.
+ */
+const toState = (status: EdgeTriggerStatus): Trigger.State => ({
+  // Space-relative echo ref (same shape as `Ref.make(trigger)` for an in-space object), resolvable
+  // against the space database where the edge trigger is replicated.
+  trigger: Ref.fromURI(EID.make({ entityId: status.triggerId })),
+  environment: 'edge',
+  nextExecution: status.nextExecutionTimestamp !== undefined ? new Date(status.nextExecutionTimestamp) : undefined,
+  cooldownUntil: status.cooldownUntilTimestamp !== undefined ? new Date(status.cooldownUntilTimestamp) : undefined,
+  lastResult: toExit(status.lastResult),
+});
+
+const toExit = (result: EdgeTriggerStatus['lastResult']): Exit.Exit<unknown> | null => {
+  if (!result) {
+    return null;
+  }
+  // The original error channel is not reconstructed over the wire, so failures are surfaced as
+  // defects carrying the serialized message.
+  return result.status === 'success'
+    ? Exit.void
+    : Exit.die(new Error(result.error?.message ?? 'Edge trigger invocation failed'));
+};
+
+const make = (
+  getEdgeClient: () => EdgeClient,
+  spaceId: SpaceId,
+  registry: Registry.Registry,
+): Effect.Effect<RemoteTriggerManager.Manager, never, Scope.Scope> =>
+  Effect.gen(function* () {
+    const triggers = Atom.make<readonly Trigger.State[]>([]);
+    registry.mount(triggers);
+
+    const refresh = Effect.tryPromise(() => getEdgeClient().getSpaceTriggers(DxosContext.default(), spaceId)).pipe(
+      Effect.tap((response) => Effect.sync(() => registry.update(triggers, () => response.triggers.map(toState)))),
+      // The endpoint may be unimplemented or unreachable; a failed poll must not tear down the layer.
+      Effect.catchAll(() => Effect.void),
+    );
+
+    // Poll the EDGE dispatcher on an interval; the fiber is scoped to the layer's lifetime.
+    yield* refresh.pipe(Effect.repeat(Schedule.spaced(POLL_INTERVAL)), Effect.forkScoped);
+
+    return {
+      triggers,
+      invokeTrigger: (options: Trigger.InvokeOptions) =>
+        // Manual invocation of a remote trigger maps onto force-running its cron on the EDGE
+        // dispatcher; refresh the view promptly afterwards.
+        Effect.promise(() =>
+          getEdgeClient().forceRunCronTrigger(DxosContext.default(), spaceId, options.trigger.id),
+        ).pipe(
+          Effect.asVoid,
+          Effect.orDie,
+          Effect.tap(() => refresh),
+        ),
+    } satisfies RemoteTriggerManager.Manager;
+  });
+
+/**
+ * For tests: provide a pre-built edge client.
  */
-const make = (_spaceId?: SpaceId): Layer.Layer<RemoteTriggerManager.Service, never, Registry.AtomRegistry> =>
-  Layer.effect(
+export const fromEdgeClient = (
+  edgeClient: EdgeClient,
+  spaceId: SpaceId,
+): Layer.Layer<RemoteTriggerManager.Service, never, Registry.AtomRegistry> =>
+  Layer.scoped(
     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;
+      return yield* make(() => edgeClient, spaceId, registry);
     }),
   );
 
 /**
- * Build from a `Client`.
+ * Build from a `Client`, deferring edge-client creation until first use
+ * (identity may be absent at boot).
  */
 export const fromClient = (
-  _client: Client,
-  spaceId?: SpaceId,
-): Layer.Layer<RemoteTriggerManager.Service, never, Registry.AtomRegistry> => make(spaceId);
+  client: Client,
+  spaceId: SpaceId,
+): Layer.Layer<RemoteTriggerManager.Service, never, Registry.AtomRegistry> =>
+  Layer.scoped(
+    RemoteTriggerManager.Service,
+    Effect.gen(function* () {
+      const registry = yield* Registry.AtomRegistry;
+      let cached: EdgeClient | undefined;
+      return yield* make(() => (cached ??= createEdgeClient(client)), spaceId, registry);
+    }),
+  );
 
 /**
  * Build from the ambient `ClientService`.
  */
 export const layer = (
-  spaceId?: SpaceId,
+  spaceId: SpaceId,
 ): Layer.Layer<RemoteTriggerManager.Service, never, Registry.AtomRegistry | ClientService> =>
-  Layer.effect(
+  Layer.scoped(
     RemoteTriggerManager.Service,
     Effect.gen(function* () {
-      yield* ClientService;
+      const client = 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;
+      let cached: EdgeClient | undefined;
+      return yield* make(() => (cached ??= createEdgeClient(client)), spaceId, registry);
     }),
   );

package/src/native/bundler.ts

@@ -13,6 +13,7 @@ import { statSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import * as fs from 'node:fs/promises';
 import { basename, dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import { BaseError } from '@dxos/errors';
 import { PublicKey } from '@dxos/keys';
@@ -85,7 +86,13 @@ export const bundleFunction = async (options: BundleOptions): Promise<BundleResu
                 },
               };
             `,
-            resolveDir: new URL('.', import.meta.url).pathname,
+            // NOTE: Compute the module directory via `fileURLToPath`, not
+            // `new URL('.', import.meta.url)`. Vite's library-mode build treats the latter as an
+            // asset reference and base64-inlines the resolved `.ts` module as a
+            // `data:video/mp2t;base64,…` data URL, so `resolveDir` becomes garbage in `dist` and
+            // the bundler can no longer resolve `@dxos/compute-runtime` /
+            // `@dxos/functions-runtime-cloudflare`.
+            resolveDir: dirname(fileURLToPath(import.meta.url)),
           }));
         },
       },

package/src/testing/services.ts

@@ -3,11 +3,11 @@
 //
 
 import type * as Context from 'effect/Context';
+import * as Layer from 'effect/Layer';
 
 import type { Space } from '@dxos/client/echo';
-import { type Credential, type Trace } from '@dxos/compute';
+import { Credential, Trace } from '@dxos/compute';
 import { ConfiguredCredentialsService } from '@dxos/compute-runtime';
-import { ServiceContainer } from '@dxos/compute-runtime';
 import { Database } from '@dxos/echo';
 import { type EchoDatabase } from '@dxos/echo-client';
 import { assertArgument } from '@dxos/invariant';
@@ -63,23 +63,29 @@ export type TestServiceOptions = {
 };
 
 /**
- * @deprecated
+ * Composes the foundational Effect layers available to compute nodes and operations in tests:
+ * credentials, database (from a space or standalone database), and trace. Callers layer AI,
+ * `Operation.Service`, and registry on top as needed for the code under test.
  */
-export const createTestServices = ({
-  ai,
-  credentials,
-  db,
-  logging,
-  space,
-}: TestServiceOptions = {}): ServiceContainer => {
+export const createTestServices = ({ credentials, db, logging, space }: TestServiceOptions = {}): Layer.Layer<
+  Credential.CredentialsService | Database.Service | Trace.TraceService
+> => {
   assertArgument(!(!!space && !!db), 'space', 'space can be provided only if db is not');
 
-  return new ServiceContainer().setServices({
-    // ai: createAiService(ai),
-    credentials: createCredentialsService(credentials),
-    database: space || db ? Database.makeService(space?.db || db!) : undefined,
-    trace: logging?.trace ?? (logging?.enabled ? consoleTraceWriter : noopTraceWriter),
-  });
+  const credentialsLayer = Layer.succeed(
+    Credential.CredentialsService,
+    createCredentialsService(credentials) ?? new ConfiguredCredentialsService(),
+  );
+
+  const database = space?.db ?? db;
+  const databaseLayer = database ? Database.layer(database) : Database.notAvailable;
+
+  const traceLayer = Layer.succeed(
+    Trace.TraceService,
+    logging?.trace ?? (logging?.enabled ? consoleTraceWriter : noopTraceWriter),
+  );
+
+  return Layer.mergeAll(credentialsLayer, databaseLayer, traceLayer);
 };
 
 const createCredentialsService = (