@dxos/compute 0.8.4-main.f9ba587 → 0.8.4-main.fcfe5033a5

package/package.json

@@ -1,29 +1,27 @@
 {
   "name": "@dxos/compute",
-  "version": "0.8.4-main.f9ba587",
+  "version": "0.8.4-main.fcfe5033a5",
   "description": "Low-level compute API",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "DXOS.org",
   "sideEffects": true,
   "type": "module",
-  "imports": {
-    "#hyperformula": {
-      "types": "hyperformula",
-      "default": "./dist/vendor/hyperformula.mjs"
-    }
-  },
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     },
     "./testing": {
+      "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
-      "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/index.mjs"
+      "default": "./dist/lib/neutral/testing/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -39,35 +37,35 @@
     "src"
   ],
   "dependencies": {
-    "@preact/signals-core": "^1.9.0",
-    "effect": "3.16.13",
-    "hyperformula": "^2.7.1",
+    "effect": "3.20.0",
     "lodash.defaultsdeep": "^4.6.1",
-    "@dxos/async": "0.8.4-main.f9ba587",
-    "@dxos/client": "0.8.4-main.f9ba587",
-    "@dxos/context": "0.8.4-main.f9ba587",
-    "@dxos/debug": "0.8.4-main.f9ba587",
-    "@dxos/echo": "0.8.4-main.f9ba587",
-    "@dxos/echo-db": "0.8.4-main.f9ba587",
-    "@dxos/functions": "0.8.4-main.f9ba587",
-    "@dxos/echo-schema": "0.8.4-main.f9ba587",
-    "@dxos/invariant": "0.8.4-main.f9ba587",
-    "@dxos/keys": "0.8.4-main.f9ba587",
-    "@dxos/live-object": "0.8.4-main.f9ba587",
-    "@dxos/log": "0.8.4-main.f9ba587",
-    "@dxos/protocols": "0.8.4-main.f9ba587",
-    "@dxos/schema": "0.8.4-main.f9ba587",
-    "@dxos/util": "0.8.4-main.f9ba587"
+    "@dxos/ai": "0.8.4-main.fcfe5033a5",
+    "@dxos/async": "0.8.4-main.fcfe5033a5",
+    "@dxos/debug": "0.8.4-main.fcfe5033a5",
+    "@dxos/client": "0.8.4-main.fcfe5033a5",
+    "@dxos/echo": "0.8.4-main.fcfe5033a5",
+    "@dxos/context": "0.8.4-main.fcfe5033a5",
+    "@dxos/functions-runtime": "0.8.4-main.fcfe5033a5",
+    "@dxos/invariant": "0.8.4-main.fcfe5033a5",
+    "@dxos/log": "0.8.4-main.fcfe5033a5",
+    "@dxos/operation": "0.8.4-main.fcfe5033a5",
+    "@dxos/plugin-automation": "0.8.4-main.fcfe5033a5",
+    "@dxos/keys": "0.8.4-main.fcfe5033a5",
+    "@dxos/protocols": "0.8.4-main.fcfe5033a5",
+    "@dxos/schema": "0.8.4-main.fcfe5033a5",
+    "@dxos/util": "0.8.4-main.fcfe5033a5",
+    "@dxos/functions": "0.8.4-main.fcfe5033a5",
+    "@dxos/vendor-hyperformula": "0.8.4-main.fcfe5033a5"
   },
   "devDependencies": {
     "@tldraw/indices": "^2.0.0-alpha.14",
     "@types/lodash.defaultsdeep": "^4.6.6",
-    "@dxos/echo-db": "0.8.4-main.f9ba587",
-    "@dxos/echo-schema": "0.8.4-main.f9ba587",
-    "@dxos/random": "0.8.4-main.f9ba587"
+    "@dxos/echo": "0.8.4-main.fcfe5033a5",
+    "@dxos/echo-db": "0.8.4-main.fcfe5033a5",
+    "@dxos/random": "0.8.4-main.fcfe5033a5"
   },
   "peerDependencies": {
-    "effect": "^3.13.3"
+    "effect": "3.20.0"
   },
   "publishConfig": {
     "access": "public"

package/src/compute-graph-registry.test.ts

@@ -0,0 +1,167 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+import { describe, expect, onTestFinished, test } from 'vitest';
+
+import { Trigger } from '@dxos/async';
+import { Obj } from '@dxos/echo';
+import { Operation, OperationHandlerSet } from '@dxos/operation';
+
+import { ComputeGraphRegistry, defaultPlugins } from './compute-graph-registry';
+import { TestBuilder, createMockedComputeRuntimeProvider } from './testing';
+
+const AddDefinition = Operation.make({
+  meta: {
+    key: 'add',
+    name: 'add',
+    description: 'Adds two numbers',
+  },
+  input: Schema.Struct({ a: Schema.Number, b: Schema.Number }),
+  output: Schema.Number,
+  services: [],
+});
+
+const add = AddDefinition.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ a, b }) {
+      return a + b;
+    }),
+  ),
+);
+
+describe('ComputeGraphRegistry', () => {
+  test('invokes user function through compute graph', async () => {
+    const computeRuntime = createMockedComputeRuntimeProvider({
+      functions: OperationHandlerSet.make(add),
+    });
+    const testBuilder = new TestBuilder({
+      types: [Operation.PersistentOperation],
+      computeRuntime,
+    });
+    await testBuilder.open();
+    onTestFinished(async () => {
+      await testBuilder.close();
+    });
+
+    const space = await testBuilder.client.spaces.create();
+
+    // Register Edge function plugin and runtime in the registry.
+    const registry = new ComputeGraphRegistry({
+      plugins: defaultPlugins,
+      computeRuntime,
+    });
+    await registry.open();
+    onTestFinished(async () => {
+      await registry.close();
+    });
+
+    const graph = registry.createGraph(space);
+    await graph.open();
+    onTestFinished(async () => {
+      await graph.close();
+    });
+
+    const functionObj = Operation.serialize(add);
+    Obj.change(functionObj, (functionObj) => {
+      functionObj.binding = 'ADD';
+    });
+    space.db.add(functionObj);
+
+    const node = await graph.getOrCreateNode('sheet').open();
+
+    // Wait for value update after async invocation completes.
+    const trigger = new Trigger<number>();
+    node.update.on(() => {
+      const value = node.getValue({ row: 0, col: 0 });
+      if (typeof value === 'number') {
+        trigger.wake(value);
+      }
+    });
+
+    // Set formula using binding; graph will map to DX("ADD", ...)
+    node.setValue({ row: 0, col: 0 }, '=ADD(2, 3)');
+
+    const result = await trigger.wait();
+    expect(result).to.equal(5);
+
+    // Sanity check: mapping to fully qualified id works as well.
+    const bindingId = graph.mapFunctionBindingToId('ADD(2, 3)');
+    expect(bindingId.startsWith(`${Obj.getDXN(functionObj).toString()}`)).to.be.true;
+  });
+
+  test('adding a function binding updates autocomplete and enables execution', async () => {
+    const computeRuntime = createMockedComputeRuntimeProvider({
+      functions: OperationHandlerSet.make(add),
+    });
+    const testBuilder = new TestBuilder({
+      types: [Operation.PersistentOperation],
+      computeRuntime,
+    });
+    await testBuilder.open();
+    onTestFinished(async () => {
+      await testBuilder.close();
+    });
+
+    const space = await testBuilder.client.spaces.create();
+
+    const registry = new ComputeGraphRegistry({
+      plugins: defaultPlugins,
+      computeRuntime,
+    });
+    await registry.open();
+    onTestFinished(async () => {
+      await registry.close();
+    });
+
+    const graph = registry.createGraph(space);
+    await graph.open();
+    onTestFinished(async () => {
+      await graph.close();
+    });
+
+    // Initially there should be no echo functions.
+    expect(graph.getFunctions({ standard: false, echo: true }).length).to.equal(0);
+
+    // Subscribe for function updates.
+    const functionsUpdated = new Trigger<void>();
+    const unsubscribe = graph.update.on((e) => {
+      if (e.type === 'functionsUpdated') {
+        functionsUpdated.wake();
+      }
+    });
+    onTestFinished(unsubscribe);
+
+    const functionObj = Operation.serialize(add);
+    Obj.change(functionObj, (functionObj) => {
+      functionObj.binding = 'ADD';
+    });
+    space.db.add(functionObj);
+
+    await functionsUpdated.wait();
+
+    // Autocomplete should now include the binding.
+    const echoFunctions = graph.getFunctions({ standard: false, echo: true }).map((fn) => fn.name);
+    expect(echoFunctions).toContain('ADD');
+
+    // And the binding should execute when used in a formula.
+    const node = await graph.getOrCreateNode('sheet').open();
+    onTestFinished(async () => {
+      await node.close();
+    });
+
+    const valueSettled = new Trigger<number>();
+    node.update.on(() => {
+      const value = node.getValue({ row: 0, col: 0 });
+      if (typeof value === 'number') {
+        valueSettled.wake(value);
+      }
+    });
+
+    node.setValue({ row: 0, col: 0 }, '=ADD(2, 3)');
+    const result = await valueSettled.wait();
+    expect(result).to.equal(5);
+  });
+});

package/src/compute-graph-registry.ts

@@ -2,17 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import type { FunctionPluginDefinition } from 'hyperformula';
-import type { ConfigParams } from 'hyperformula/typings/ConfigParams';
-import type { FunctionTranslationsPackage } from 'hyperformula/typings/interpreter';
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
 import defaultsDeep from 'lodash.defaultsdeep';
 
-import { type SpaceId, type Space } from '@dxos/client/echo';
+import { type Space, type SpaceId } from '@dxos/client/echo';
 import { Resource } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
+import type { Operation } from '@dxos/operation';
+import type { ConfigParams, FunctionPluginDefinition, FunctionTranslationsPackage } from '@dxos/vendor-hyperformula';
+import { HyperFormula } from '@dxos/vendor-hyperformula';
 
-import { HyperFormula } from '#hyperformula';
 import { ComputeGraph } from './compute-graph';
 import { EdgeFunctionPlugin, EdgeFunctionPluginTranslations, type FunctionContextOptions } from './functions';
 
@@ -21,15 +21,16 @@ export type ComputeGraphPlugin = {
   translations: FunctionTranslationsPackage;
 };
 
+export type FunctionsRuntimeProvider = {
+  getRuntime(spaceId: SpaceId): ManagedRuntime.ManagedRuntime<Operation.Service, never>;
+};
+
 export type ComputeGraphOptions = {
   plugins?: ComputeGraphPlugin[];
+  computeRuntime: FunctionsRuntimeProvider;
 } & Partial<FunctionContextOptions> &
   Partial<ConfigParams>;
 
-export const defaultOptions: ComputeGraphOptions = {
-  licenseKey: 'gpl-v3',
-};
-
 export const defaultPlugins: ComputeGraphPlugin[] = [
   {
     plugin: EdgeFunctionPlugin,
@@ -37,23 +38,26 @@ export const defaultPlugins: ComputeGraphPlugin[] = [
   },
 ];
 
+export const defaultOptions: Partial<ComputeGraphOptions> = {
+  licenseKey: 'gpl-v3',
+};
+
 /**
  * Manages a collection of ComputeGraph instances for each space.
  *
  * [ComputePlugin] => [ComputeGraphRegistry] => [ComputeGraph(Space)] => [ComputeNode(Object)]
  *
  * NOTE: The ComputeGraphRegistry manages the hierarchy of resources via its root Context.
- * NOTE: The package.json file defines the packaged #hyperformula module.
  */
 // TODO(burdon): Move graph into separate plugin; isolate HF deps.
 export class ComputeGraphRegistry extends Resource {
   private readonly _graphs = new Map<SpaceId, ComputeGraph>();
-
   private readonly _options: ComputeGraphOptions;
 
-  constructor(options: ComputeGraphOptions = { plugins: defaultPlugins }) {
+  constructor(options: ComputeGraphOptions) {
     super();
     this._options = defaultsDeep({}, options, defaultOptions);
+    this._options.plugins = this._options.plugins ?? defaultPlugins;
     this._options.plugins?.forEach(({ plugin, translations }) => {
       HyperFormula.registerFunctionPlugin(plugin, translations);
     });
@@ -76,7 +80,10 @@ export class ComputeGraphRegistry extends Resource {
   createGraph(space: Space): ComputeGraph {
     invariant(!this._graphs.has(space.id), `ComputeGraph already exists for space: ${space.id}`);
     const hf = HyperFormula.buildEmpty(this._options);
-    const graph = new ComputeGraph(hf, space, this._options);
+    invariant(this._options.computeRuntime, 'ComputeRuntime is required');
+    const runtime = this._options.computeRuntime.getRuntime(space.id);
+
+    const graph = new ComputeGraph(hf, runtime, space, this._options);
     this._graphs.set(space.id, graph);
     return graph;
   }

package/src/compute-graph.test.ts

@@ -2,21 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type CellValue } from 'hyperformula';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
-import { fullyQualifiedId } from '@dxos/client/echo';
 import { Obj } from '@dxos/echo';
-import { FunctionType } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+import { type CellValue } from '@dxos/vendor-hyperformula';
+import { DetailedCellError } from '@dxos/vendor-hyperformula';
 
-import { DetailedCellError } from '#hyperformula';
 import { TestBuilder } from './testing';
 
 describe('ComputeGraph', () => {
   let testBuilder: TestBuilder;
   beforeEach(async () => {
-    testBuilder = new TestBuilder({ types: [FunctionType] });
+    testBuilder = new TestBuilder({ types: [Operation.PersistentOperation] });
     await testBuilder.open();
   });
   afterEach(async () => {
@@ -31,13 +30,45 @@ describe('ComputeGraph', () => {
     // Create script.
     const trigger = new Trigger();
     graph.update.once(() => trigger.wake());
-    const functionObject = space.db.add(Obj.make(FunctionType, { name: 'test', version: '0.0.1', binding: 'TEST' }));
+    const functionObject = space.db.add(
+      Obj.make(Operation.PersistentOperation, { name: 'test', version: '0.0.1', binding: 'TEST' }),
+    );
     await trigger.wait();
     const functions = graph.getFunctions({ echo: true });
     expect(functions).to.toHaveLength(1);
 
     const id = graph.mapFunctionBindingToId('TEST()');
-    expect(id).to.eq(`${fullyQualifiedId(functionObject)}()`);
+    expect(id).to.eq(`${Obj.getDXN(functionObject).toString()}()`);
+
+    const restored = graph.mapFunctionBindingFromId(id);
+    expect(restored).to.eq('TEST()');
+  });
+
+  test('map functions roundtrip with args', async () => {
+    const space = await testBuilder.client.spaces.create();
+    const graph = testBuilder.registry.createGraph(space);
+    await graph.open();
+
+    const trigger = new Trigger();
+    graph.update.once(() => trigger.wake());
+    space.db.add(Obj.make(Operation.PersistentOperation, { name: 'forex', version: '0.0.1', binding: 'FOREX' }));
+    await trigger.wait();
+
+    const stored = graph.mapFunctionBindingToId('=FOREX(C6,C7)');
+    expect(stored).to.include('dxn:echo:');
+    expect(stored).not.to.include('FOREX');
+
+    const restored = graph.mapFunctionBindingFromId(stored);
+    expect(restored).to.eq('=FOREX(C6,C7)');
+  });
+
+  test('map functions unknown binding returns undefined', async () => {
+    const space = await testBuilder.client.spaces.create();
+    const graph = testBuilder.registry.createGraph(space);
+    await graph.open();
+
+    const result = graph.mapFunctionBindingFromId('=dxn:echo:@:01ABCDEF01ABCDEF01ABCDEF01(A1,B1)');
+    expect(result).to.be.undefined;
   });
 
   test('cross-node references', async () => {
@@ -52,22 +83,38 @@ describe('ComputeGraph', () => {
     {
       node1.graph.hf.setCellContents({ sheet: node1.sheetId, row: 0, col: 0 }, [[100, 200, 300, '=SUM(A1:C1)']]);
       node2.graph.hf.setCellContents({ sheet: node2.sheetId, row: 0, col: 0 }, "='node-1'!D1");
-      const value1 = node1.graph.hf.getCellValue({ sheet: node1.sheetId, col: 3, row: 0 });
-      const value2 = node2.graph.hf.getCellValue({ sheet: node2.sheetId, col: 0, row: 0 });
+      const value1 = node1.graph.hf.getCellValue({
+        sheet: node1.sheetId,
+        col: 3,
+        row: 0,
+      });
+      const value2 = node2.graph.hf.getCellValue({
+        sheet: node2.sheetId,
+        col: 0,
+        row: 0,
+      });
       expect(value1).to.eq(value2);
     }
 
     // Get updated event.
     const trigger = new Trigger<CellValue>();
     node2.update.on(({ change }) => {
-      const value = node2.graph.hf.getCellValue({ sheet: node2.sheetId, col: 0, row: 0 });
+      const value = node2.graph.hf.getCellValue({
+        sheet: node2.sheetId,
+        col: 0,
+        row: 0,
+      });
       expect(value).to.eq(change?.newValue);
       trigger.wake(value);
     });
 
     {
       node1.graph.hf.setCellContents({ sheet: node1.sheetId, row: 0, col: 0 }, 400);
-      const value1 = node1.graph.hf.getCellValue({ sheet: node1.sheetId, col: 3, row: 0 });
+      const value1 = node1.graph.hf.getCellValue({
+        sheet: node1.sheetId,
+        col: 3,
+        row: 0,
+      });
       const value2 = await trigger.wait();
       expect(value1).to.eq(value2);
     }
@@ -81,7 +128,11 @@ describe('ComputeGraph', () => {
 
     const node1 = await graph.getOrCreateNode('node-1').open();
     node1.graph.hf.setCellContents({ sheet: node1.sheetId, row: 0, col: 0 }, "='node-2'!A1");
-    const value1 = node1.graph.hf.getCellValue({ sheet: node1.sheetId, col: 0, row: 0 });
+    const value1 = node1.graph.hf.getCellValue({
+      sheet: node1.sheetId,
+      col: 0,
+      row: 0,
+    });
     expect(value1).to.be.instanceof(DetailedCellError);
     expect((value1 as DetailedCellError).type).to.eq('REF');
   });

package/src/compute-graph.ts

@@ -2,27 +2,27 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Listeners } from 'hyperformula/typings/Emitter';
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
 
 import { Event } from '@dxos/async';
-import { type Space, Filter, fullyQualifiedId } from '@dxos/client/echo';
-import { FQ_ID_LENGTH } from '@dxos/client/echo';
+import { Filter, type Space } from '@dxos/client/echo';
 import { Resource } from '@dxos/context';
-import { getTypename } from '@dxos/echo-schema';
-import { FunctionType } from '@dxos/functions';
+import { Obj } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
 import { isNonNullable } from '@dxos/util';
+import type { Listeners } from '@dxos/vendor-hyperformula';
+import { ExportedCellChange, type HyperFormula } from '@dxos/vendor-hyperformula';
 
-import { ExportedCellChange, type HyperFormula } from '#hyperformula';
 import { ComputeNode } from './compute-node';
 import {
-  defaultFunctions,
+  EDGE_FUNCTION_NAME,
   FunctionContext,
   type FunctionContextOptions,
   type FunctionDefinition,
-  EDGE_FUNCTION_NAME,
+  defaultFunctions,
 } from './functions';
 
 // TODO(burdon): Factor out compute-graph.
@@ -36,7 +36,7 @@ type ObjectRef = { type: string; id: string };
 
 /**
  * Marker for sheets that are managed by an ECHO object.
- * Sheet ID: `dxos.org/type/SheetType@1234`
+ * Sheet ID: `org.dxos.type.sheet-type@1234`
  */
 export const createSheetName = ({ type, id }: ObjectRef) => `${type}@${id}`;
 export const parseSheetName = (name: string): Partial<ObjectRef> => {
@@ -59,7 +59,7 @@ export class ComputeGraph extends Resource {
   private readonly _nodes = new Map<number, ComputeNode>();
 
   // Cached function objects.
-  private _remoteFunctions: FunctionType[] = [];
+  private _remoteFunctions: Operation.PersistentOperation[] = [];
 
   public readonly update = new Event<{ type: ComputeGraphEvent }>();
 
@@ -68,12 +68,13 @@ export class ComputeGraph extends Resource {
 
   constructor(
     private readonly _hf: HyperFormula,
+    private readonly _runtime: ManagedRuntime.ManagedRuntime<Operation.Service, never>,
     private readonly _space?: Space,
     private readonly _options?: Partial<FunctionContextOptions>,
   ) {
     super();
 
-    this.context = new FunctionContext(this._hf, this._space, {
+    this.context = new FunctionContext(this._hf, this._runtime, this._space, {
       ...this._options,
       onUpdate: (update) => {
         this._options?.onUpdate?.(update);
@@ -104,7 +105,10 @@ export class ComputeGraph extends Resource {
   }
 
   getFunctions(
-    { standard, echo }: { standard?: boolean; echo?: boolean } = { standard: true, echo: true },
+    { standard, echo }: { standard?: boolean; echo?: boolean } = {
+      standard: true,
+      echo: true,
+    },
   ): FunctionDefinition[] {
     return [
       ...(standard
@@ -148,7 +152,7 @@ export class ComputeGraph extends Resource {
       formula
         //
         // Map cross-sheet references by name onto sheet stored by ECHO object/model.
-        // Example: "Test Sheet"!A0 => "dxos.org/type/SheetType@1234"!A0
+        // Example: "Test Sheet"!A0 => "org.dxos.type.sheet-type@1234"!A0
         // https://hyperformula.handsontable.com/guide/cell-references.html#cell-references
         //
         .replace(/['"]?([ \w]+)['"]?!/, (_match, name) => {
@@ -164,7 +168,7 @@ export class ComputeGraph extends Resource {
 
             for (const obj of objects) {
               if (obj.name === name) {
-                const type = getTypename(obj)!;
+                const type = Obj.getTypename(obj)!;
                 // NOTE: Names must be single quoted.
                 return `'${createSheetName({ type, id: obj.id })}'!`;
               }
@@ -193,8 +197,8 @@ export class ComputeGraph extends Resource {
   }
 
   /**
-   * Map from binding to fully qualified ECHO ID (to store).
-   * E.g., HELLO() => spaceId:objectId()
+   * Map from binding to fully qualified ECHO DXN (to store).
+   * E.g., HELLO() => dxn:echo:spaceId:objectId()
    */
   mapFunctionBindingToId(formula: string): string {
     return formula.replace(/(\w+)\((.*)\)/g, (match, binding, args) => {
@@ -204,7 +208,7 @@ export class ComputeGraph extends Resource {
 
       const fn = this._remoteFunctions.find((fn) => fn.binding === binding);
       if (fn) {
-        const id = fullyQualifiedId(fn);
+        const id = Obj.getDXN(fn).toString();
         return `${id}(${args})`;
       } else {
         return match;
@@ -213,23 +217,22 @@ export class ComputeGraph extends Resource {
   }
 
   /**
-   * Map from fully qualified ECHO ID to binding (from store).
-   * E.g., spaceId:objectId() => HELLO()
+   * Map from fully qualified ECHO DXN to binding (from store).
+   * E.g., dxn:echo:spaceId:objectId() => HELLO()
    */
   mapFunctionBindingFromId(formula: string): string | undefined {
-    const binding = formula.replace(/(\w+):([a-zA-Z0-9]+)\((.*)\)/g, (match, spaceId, objectId, args) => {
-      const id = `${spaceId}:${objectId}`;
-      if (id.length !== FQ_ID_LENGTH) {
-        return match;
-      }
-
-      const fn = this._remoteFunctions.find((fn) => fullyQualifiedId(fn) === id);
-      if (fn?.binding) {
-        return `${fn.binding}(${args})`;
-      } else {
-        return UNKNOWN_BINDING;
-      }
-    });
+    const binding = formula.replace(
+      /dxn:([^:]+):([^:(]+):([a-zA-Z0-9]+)\((.*)\)/g,
+      (_match, kind, spaceTag, objectId, args) => {
+        const dxn = `dxn:${kind}:${spaceTag}:${objectId}`;
+        const fn = this._remoteFunctions.find((fn) => Obj.getDXN(fn).toString() === dxn);
+        if (fn?.binding) {
+          return `${fn.binding}(${args})`;
+        } else {
+          return UNKNOWN_BINDING;
+        }
+      },
+    );
 
     if (binding.startsWith(`=${UNKNOWN_BINDING}`)) {
       return undefined;
@@ -241,11 +244,14 @@ export class ComputeGraph extends Resource {
   protected override async _open(): Promise<void> {
     if (this._space) {
       // Subscribe to remote function definitions.
-      const query = this._space.db.query(Filter.type(FunctionType));
-      const unsubscribe = query.subscribe(({ objects }) => {
-        this._remoteFunctions = objects.filter(({ binding }) => binding);
-        this.update.emit({ type: 'functionsUpdated' });
-      });
+      const query = this._space.db.query(Filter.type(Operation.PersistentOperation));
+      const unsubscribe = query.subscribe(
+        () => {
+          this._remoteFunctions = query.results.filter((fn) => fn.binding);
+          this.update.emit({ type: 'functionsUpdated' });
+        },
+        { fire: true },
+      );
 
       this._ctx.onDispose(unsubscribe);
     }

package/src/compute-node.ts

@@ -2,13 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Listeners } from 'hyperformula/typings/Emitter';
-import { type ExportedCellChange } from 'hyperformula/typings/Exporter';
-
 import { Event } from '@dxos/async';
 import { Resource } from '@dxos/context';
+import { type ExportedCellChange, type Listeners } from '@dxos/vendor-hyperformula';
+import { DetailedCellError } from '@dxos/vendor-hyperformula';
 
-import { DetailedCellError } from '#hyperformula';
 import { type ComputeGraph } from './compute-graph';
 import { type CellAddress, type CellScalarValue, isFormula } from './types';