@dxos/plugin-sheet 0.6.11 → 0.6.12-main.5a87ad5

package/src/{components/ComputeGraph → graph}/async-function.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { CellError, ErrorType, EmptyValue, FunctionPlugin, type HyperFormula } from 'hyperformula';
+import { type SimpleCellAddress } from 'hyperformula/typings/Cell';
 import { type InterpreterState } from 'hyperformula/typings/interpreter/InterpreterState';
 import { type InterpreterValue } from 'hyperformula/typings/interpreter/InterpreterValue';
 import { type ProcedureAst } from 'hyperformula/typings/parser';
@@ -12,6 +12,8 @@ import { debounce, type UnsubscribeCallback } from '@dxos/async';
 import { type Space } from '@dxos/client/echo';
 import { log } from '@dxos/log';
 
+import { CellError, ErrorType, EmptyValue, FunctionPlugin, type HyperFormula } from '#hyperformula';
+
 // TODO(burdon): API gateways!
 //  https://publicapis.io
 //  https://api-ninjas.com/api/cryptoprice
@@ -21,6 +23,11 @@ import { log } from '@dxos/log';
 // TODO(burdon): Create wrapper.
 export type AsyncFunction = (...args: any) => Promise<InterpreterValue>;
 
+export type FunctionUpdateEvent = {
+  name: string;
+  cell: SimpleCellAddress;
+};
+
 export type FunctionOptions = {
   ttl?: number;
 };
@@ -29,6 +36,7 @@ export type FunctionContextOptions = {
   defaultTtl: number;
   recalculationDelay: number;
   remoteFunctionUrl: string;
+  onUpdate?: (update: FunctionUpdateEvent) => void;
 };
 
 export const defaultFunctionContextOptions: FunctionContextOptions = {
@@ -65,20 +73,21 @@ export class FunctionContext {
   private _invocations: Record<string, number> = {};
 
   private readonly _options: FunctionContextOptions;
-  private readonly _onUpdate: () => void;
+
+  // Debounced update handler.
+  private readonly _onUpdate: (update: FunctionUpdateEvent) => void;
 
   constructor(
     private readonly _hf: HyperFormula,
     private readonly _space: Space | undefined,
-    onUpdate: (context: FunctionContext) => void,
     _options?: Partial<FunctionContextOptions>,
   ) {
     this._options = defaultsDeep(_options ?? {}, defaultFunctionContextOptions);
-    this._onUpdate = debounce(() => {
+    this._onUpdate = debounce((update) => {
       // TODO(burdon): Better way to trigger recalculation?
       //  NOTE: rebuildAndRecalculate resets the undo history.
       this._hf.resumeEvaluation();
-      onUpdate(this);
+      this._options.onUpdate?.(update);
     }, this._options.recalculationDelay);
   }
 
@@ -134,7 +143,7 @@ export class FunctionContext {
           const value = await cb(...args);
           this._cache.set(invocationKey, { value, ts: Date.now() });
           log('set', { cell, value });
-          this._onUpdate();
+          this._onUpdate({ name, cell });
         } catch (err) {
           // TODO(burdon): Show error to user.
           log.warn('failed', { cell, err });

package/src/graph/compute-graph.stories.tsx

@@ -0,0 +1,93 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import '@dxos-theme';
+
+import React, { useEffect, useRef, useState } from 'react';
+
+import { FunctionType } from '@dxos/plugin-script/types';
+import { create, useSpace, Filter } from '@dxos/react-client/echo';
+import { withClientProvider } from '@dxos/react-client/testing';
+import { Toolbar, Button, Input } from '@dxos/react-ui';
+import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
+import { withTheme } from '@dxos/storybook-utils';
+
+import { testPlugins } from './testing';
+import { createSheet } from '../defs';
+import { useComputeGraph, useSheetModel } from '../hooks';
+import { withComputeGraphDecorator } from '../testing';
+import { SheetType } from '../types';
+
+const FUNCTION_NAME = 'TEST';
+
+const Story = () => {
+  const space = useSpace();
+  const graph = useComputeGraph(space);
+  const [sheet, setSheet] = useState<SheetType>();
+  const [text, setText] = useState(`${FUNCTION_NAME}(100)`);
+  const [result, setResult] = useState<any>();
+  const model = useSheetModel(graph, sheet);
+  useEffect(() => {
+    if (space) {
+      const sheet = space.db.add(createSheet());
+      setSheet(sheet);
+    }
+  }, [space]);
+
+  useEffect(() => {
+    if (space && graph) {
+      graph.update.on(() => {
+        const f1 = graph.getFunctions({ standard: true, echo: false });
+        const f2 = graph.getFunctions({ standard: false, echo: true });
+        setResult({ functions: { standard: f1.length, echo: f2.length } });
+      });
+
+      space.db.add(create(FunctionType, { version: 1, binding: FUNCTION_NAME }));
+    }
+  }, [space, graph]);
+
+  const inputRef = useRef<HTMLInputElement | null>(null);
+  const handleTest = async () => {
+    if (space && graph) {
+      const { objects } = await space.db.query(Filter.schema(FunctionType)).run();
+      const mapped = graph.mapFunctionBindingToId(text);
+      const unmapped = graph.mapFunctionBindingFromId(mapped);
+      const internal = graph.mapFormulaToNative(text);
+      setResult({ mapped, unmapped, internal, functions: objects.map((object) => object.id) });
+    }
+
+    inputRef.current?.focus();
+  };
+
+  return (
+    <div className='flex flex-col gap-2 '>
+      <Toolbar.Root>
+        <Input.Root>
+          <Input.TextInput
+            ref={inputRef}
+            placeholder='Formula'
+            value={text}
+            onChange={(ev) => setText(ev.target.value)}
+          />
+        </Input.Root>
+        <Button onClick={handleTest}>Test</Button>
+      </Toolbar.Root>
+      <SyntaxHighlighter language='json'>
+        {JSON.stringify({ space: space?.id, graph: graph?.id, sheet: sheet?.id, model: model?.id, result }, null, 2)}
+      </SyntaxHighlighter>
+    </div>
+  );
+};
+
+export default {
+  title: 'plugin-sheet/functions',
+  decorators: [
+    withClientProvider({ types: [FunctionType, SheetType], createIdentity: true, createSpace: true }),
+    withComputeGraphDecorator({ plugins: testPlugins }),
+    withTheme,
+  ],
+  render: (args: any) => <Story {...args} />,
+};
+
+export const Default = {};

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

@@ -0,0 +1,127 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type CellValue } from 'hyperformula';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
+
+import { Trigger } from '@dxos/async';
+import { Client } from '@dxos/client';
+import { create, fullyQualifiedId } from '@dxos/client/echo';
+import { Context } from '@dxos/context';
+import { type S } from '@dxos/echo-schema';
+import { FunctionType } from '@dxos/plugin-script/types';
+
+import { ComputeGraphRegistry } from './compute-graph';
+import { testPlugins } from './testing';
+import { addressFromA1Notation, createSheet } from '../defs';
+import { SheetModel } from '../model';
+import { type CellScalarValue } from '../types';
+
+/**
+ * NOTE: Browser test required for hyperformula due to raw translation files.
+ */
+describe('compute graph', () => {
+  let ctx: Context;
+  beforeEach(() => {
+    ctx = new Context();
+  });
+  afterEach(async () => {
+    await ctx.dispose();
+  });
+
+  // TODO(burdon): Replace with builder.
+  const createModel = async (types?: S.Schema<any>[]) => {
+    const client = new Client();
+    if (types) {
+      // TODO(burdon): Add to config.
+      client.addTypes(types);
+    }
+    await client.initialize();
+    await client.halo.createIdentity();
+    const space = await client.spaces.create();
+    ctx.onDispose(() => client.destroy());
+
+    const registry = new ComputeGraphRegistry({ plugins: testPlugins });
+    await registry.open();
+    ctx.onDispose(() => registry.close());
+
+    const graph = await registry.createGraph(space);
+
+    const sheet = createSheet({ rows: 5, columns: 5 });
+    const model = new SheetModel(graph, sheet);
+    await model.open();
+
+    return { space, graph, model };
+  };
+
+  test('map functions', async () => {
+    const { space, graph } = await createModel([FunctionType]);
+
+    // Create script.
+    const trigger = new Trigger();
+    graph.update.once(() => trigger.wake());
+    const fn = space.db.add(create(FunctionType, { version: 1, binding: 'TEST' }));
+    await trigger.wait();
+    expect(graph.getFunctions({ echo: true })).to.toHaveLength(1);
+
+    const id = graph.mapFunctionBindingToId('TEST()');
+    expect(id).to.eq(`${fullyQualifiedId(fn)}()`);
+  });
+
+  test('cross-node references', async () => {
+    const { graph } = await createModel();
+
+    // Create nodes.
+    const node1 = await graph.getOrCreateNode('node-1');
+    const node2 = await graph.getOrCreateNode('node-2');
+
+    {
+      expect(graph.hf.getSheetNames()).to.toHaveLength(3);
+      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 });
+      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 });
+      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 value2 = await trigger.wait();
+      expect(value1).to.eq(value2);
+    }
+  });
+
+  test('async function', async () => {
+    const { graph, model } = await createModel();
+
+    // Triggers function.
+    model.setValue(addressFromA1Notation('A1'), '=TEST()');
+    const trigger = new Trigger<CellScalarValue>();
+    model.update.once(({ type }) => {
+      if (type === 'valuesUpdated') {
+        const value = model.getValue(addressFromA1Notation('A1'));
+        trigger.wake(value);
+      }
+    });
+
+    // Get initial value (null).
+    const v1 = model.getValue(addressFromA1Notation('A1'));
+    expect(v1).to.be.null;
+    expect(graph.context.info.invocations.TEST).to.eq(undefined);
+
+    // Wait until async update triggered.
+    const v2 = await trigger.wait();
+    expect(v2).not.to.be.null;
+    expect(graph.context.info.invocations.TEST).to.eq(1);
+  });
+});

package/src/graph/compute-graph.ts

@@ -0,0 +1,313 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type FunctionPluginDefinition } from 'hyperformula';
+import { type ConfigParams } from 'hyperformula/typings/ConfigParams';
+import { type Listeners } from 'hyperformula/typings/Emitter';
+import { type FunctionTranslationsPackage } from 'hyperformula/typings/interpreter';
+import defaultsDeep from 'lodash.defaultsdeep';
+
+import { Event } from '@dxos/async';
+import { type SpaceId, type Space, Filter, fullyQualifiedId } from '@dxos/client/echo';
+import { Resource } from '@dxos/context';
+import { invariant } from '@dxos/invariant';
+import { PublicKey } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { FunctionType } from '@dxos/plugin-script/types';
+import { nonNullable } from '@dxos/util';
+
+import { ExportedCellChange, HyperFormula } from '#hyperformula';
+import { FunctionContext, type FunctionContextOptions } from './async-function';
+import { ComputeNode } from './compute-node';
+import { EdgeFunctionPlugin, EdgeFunctionPluginTranslations } from './edge-function';
+import { defaultFunctions, type FunctionDefinition } from './function-defs';
+
+//
+// NOTE: The package.json file defines the packaged #hyperformula module.
+//
+
+// TODO(wittjosiah): Factor out.
+const OBJECT_ID_LENGTH = 60; // 33 (space id) + 26 (object id) + 1 (separator).
+
+// TODO(burdon): Change to "DX".
+const CUSTOM_FUNCTION = 'ECHO';
+
+export type ComputeGraphPlugin = {
+  plugin: FunctionPluginDefinition;
+  translations: FunctionTranslationsPackage;
+};
+
+export type ComputeGraphOptions = {
+  plugins?: ComputeGraphPlugin[];
+} & Partial<FunctionContextOptions> &
+  Partial<ConfigParams>;
+
+export const defaultOptions: ComputeGraphOptions = {
+  licenseKey: 'gpl-v3',
+};
+
+export const defaultPlugins: ComputeGraphPlugin[] = [
+  {
+    plugin: EdgeFunctionPlugin,
+    translations: EdgeFunctionPluginTranslations,
+  },
+];
+
+/**
+ * Marker for sheets that are managed by an ECHO object.
+ */
+const PREFIX = '__';
+export const createSheetName = (id: string) => `${PREFIX}${id}`;
+export const getSheetId = (name: string): string | undefined =>
+  name.startsWith(PREFIX) ? name.slice(PREFIX.length) : undefined;
+
+/**
+ * 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.
+ */
+// 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 }) {
+    super();
+    this._options = defaultsDeep({}, options, defaultOptions);
+    this._options.plugins?.forEach(({ plugin, translations }) => {
+      HyperFormula.registerFunctionPlugin(plugin, translations);
+    });
+  }
+
+  getGraph(spaceId: SpaceId): ComputeGraph | undefined {
+    return this._graphs.get(spaceId);
+  }
+
+  async getOrCreateGraph(space: Space): Promise<ComputeGraph> {
+    let graph = this.getGraph(space.id);
+    if (!graph) {
+      log.info('create graph', { space: space.id });
+      graph = await this.createGraph(space);
+    }
+
+    return graph;
+  }
+
+  async createGraph(space: Space): Promise<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);
+    this._graphs.set(space.id, graph);
+    await graph.open();
+    return graph;
+  }
+
+  protected override async _close() {
+    for (const graph of this._graphs.values()) {
+      await graph.close();
+    }
+  }
+}
+
+export type ComputeGraphEvent = 'functionsUpdated';
+
+/**
+ * Per-space compute and dependency graph.
+ * Consists of multiple ComputeNode (corresponding to a HyperFormula sheet).
+ * Manages the set of custom functions.
+ * HyperFormula manages the dependency graph.
+ */
+export class ComputeGraph extends Resource {
+  public readonly id = `graph-${PublicKey.random().truncate()}`;
+
+  // Map of nodes indexed by sheet number.
+  private readonly _nodes = new Map<number, ComputeNode>();
+
+  // Cached function objects.
+  private _functions: FunctionType[] = [];
+
+  public readonly update = new Event<{ type: ComputeGraphEvent }>();
+
+  // The context is passed to all functions.
+  public readonly context = new FunctionContext(this._hf, this._space, this._options);
+
+  constructor(
+    private readonly _hf: HyperFormula,
+    private readonly _space?: Space,
+    private readonly _options?: Partial<FunctionContextOptions>,
+  ) {
+    super();
+    this._hf.updateConfig({ context: this.context });
+    // TODO(burdon): If debounce then aggregate changes.
+    const onValuesUpdate: Listeners['valuesUpdated'] = (changes) => {
+      for (const change of changes) {
+        if (change instanceof ExportedCellChange) {
+          const { sheet } = change;
+          const node = this._nodes.get(sheet);
+          if (node) {
+            node.update.emit({ type: 'valuesUpdated', change });
+          }
+        }
+      }
+    };
+
+    this._hf.on('valuesUpdated', onValuesUpdate);
+    this._ctx.onDispose(() => this._hf.off('valuesUpdated', onValuesUpdate));
+  }
+
+  get hf() {
+    return this._hf;
+  }
+
+  // refresh() {
+  //   log('refresh', { id: this.id });
+  //   this.update.emit();
+  // }
+
+  getFunctions(
+    { standard, echo }: { standard?: boolean; echo?: boolean } = { standard: true, echo: true },
+  ): FunctionDefinition[] {
+    return [
+      ...(standard
+        ? this._hf
+            .getRegisteredFunctionNames()
+            .map((name) => defaultFunctions.find((fn) => fn.name === name) ?? { name })
+        : []),
+      ...(echo ? this._functions.map((fn) => ({ name: fn.binding! })) : []),
+    ];
+  }
+
+  /**
+   * Get or create cell representing a sheet.
+   */
+  // TODO(burdon): Async (open node).
+  //  The graph should be an extensible factory that plugins extend with model constructors.
+  //  This would enable on-the-fly instantiation of new models when then are referenced.
+  //  E.g., Cross-object reference would be stored as "ObjectId!A1"
+  //  The graph would then load the object and create a ComputeNode (model) of the appropriate type.
+  async getOrCreateNode(name: string): Promise<ComputeNode> {
+    invariant(name.length);
+    if (!this._hf.doesSheetExist(name)) {
+      log.info('created node', { space: this._space?.id, name });
+      this._hf.addSheet(name);
+      // this.update.emit();
+    }
+
+    const sheetId = this._hf.getSheetId(name);
+    invariant(sheetId !== undefined);
+
+    const node = new ComputeNode(this, sheetId);
+    await node.open();
+    this._nodes.set(sheetId, node);
+    return node;
+  }
+
+  /**
+   * Map bound value to custom function invocation.
+   * E.g., "HELLO(...args)" => "EDGE("HELLO", ...args)".
+   */
+  mapFormulaToNative(formula: string): string {
+    return (
+      formula
+        // Sheet references.
+        // https://hyperformula.handsontable.com/guide/cell-references.html#cell-references
+        .replace(/['"]?([ \w]+)['"]?!/, (_match, name) => {
+          if (name) {
+            // TODO(burdon): What if not loaded?
+            const objects = this._hf
+              .getSheetNames()
+              .map((name) => {
+                const id = getSheetId(name);
+                return id ? this._space?.db.getObjectById(id) : undefined;
+              })
+              .filter(nonNullable);
+
+            for (const obj of objects) {
+              if (obj.name === name || obj.title === name) {
+                return `${createSheetName(obj.id)}!`;
+              }
+            }
+          }
+
+          return `${name}!`;
+        })
+
+        // Functions.
+        .replace(/(\w+)\((.*)\)/g, (match, binding, args) => {
+          const fn = this._functions.find((fn) => fn.binding === binding);
+          if (!fn) {
+            return match;
+          }
+
+          if (args.trim() === '') {
+            return `${CUSTOM_FUNCTION}("${binding}")`;
+          } else {
+            return `${CUSTOM_FUNCTION}("${binding}", ${args})`;
+          }
+        })
+    );
+  }
+
+  /**
+   * Map from binding to fully qualified ECHO ID (to store).
+   * E.g., HELLO() => spaceId:objectId()
+   */
+  mapFunctionBindingToId(formula: string) {
+    return formula.replace(/(\w+)\((.*)\)/g, (match, binding, args) => {
+      if (binding === CUSTOM_FUNCTION || defaultFunctions.find((fn) => fn.name === binding)) {
+        return match;
+      }
+
+      const fn = this._functions.find((fn) => fn.binding === binding);
+      if (fn) {
+        const id = fullyQualifiedId(fn);
+        return `${id}(${args})`;
+      } else {
+        return match;
+      }
+    });
+  }
+
+  /**
+   * Map from fully qualified ECHO ID to binding (from store).
+   * E.g., spaceId:objectId() => HELLO()
+   */
+  mapFunctionBindingFromId(formula: string) {
+    return formula.replace(/(\w+):([a-zA-Z0-9]+)\((.*)\)/g, (match, spaceId, objectId, args) => {
+      const id = `${spaceId}:${objectId}`;
+      if (id.length !== OBJECT_ID_LENGTH) {
+        return match;
+      }
+
+      const fn = this._functions.find((fn) => fullyQualifiedId(fn) === id);
+      if (fn?.binding) {
+        return `${fn.binding}(${args})`;
+      } else {
+        return match;
+      }
+    });
+  }
+
+  protected override async _open() {
+    if (this._space) {
+      // Subscribe to remote function definitions.
+      const query = this._space.db.query(Filter.schema(FunctionType));
+      const unsubscribe = query.subscribe(({ objects }) => {
+        this._functions = objects.filter(({ binding }) => binding);
+        this.update.emit({ type: 'functionsUpdated' });
+      });
+
+      this._ctx.onDispose(unsubscribe);
+    }
+  }
+
+  protected override async _close() {
+    for (const node of this._nodes.values()) {
+      await node.close();
+    }
+  }
+}

package/src/graph/compute-node.ts

@@ -0,0 +1,62 @@
+//
+// 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 { DetailedCellError } from '#hyperformula';
+import { type ComputeGraph } from './compute-graph';
+import { type CellAddress } from '../defs';
+import { type CellScalarValue } from '../types';
+
+export type ComputeNodeEvent = {
+  type: keyof Listeners;
+  change?: ExportedCellChange;
+};
+
+/**
+ * Individual "sheet" (typically corresponds to an ECHO object).
+ */
+// TODO(burdon): Factor out common HF wrapper from from SheetModel.
+export class ComputeNode extends Resource {
+  public readonly update = new Event<ComputeNodeEvent>();
+
+  constructor(
+    private readonly _graph: ComputeGraph,
+    public readonly sheetId: number,
+  ) {
+    super();
+  }
+
+  get graph() {
+    return this._graph;
+  }
+
+  clear() {
+    this._graph.hf.clearSheet(this.sheetId);
+  }
+
+  getValue(cell: CellAddress): CellScalarValue {
+    const value = this._graph.hf.getCellValue({ sheet: this.sheetId, row: cell.row, col: cell.col });
+    if (value instanceof DetailedCellError) {
+      return null;
+    }
+
+    return value;
+  }
+
+  setValue(cell: CellAddress, value: CellScalarValue) {
+    const mappedValue =
+      typeof value === 'string' && value.charAt(0) === '=' ? this._graph.mapFormulaToNative(value) : value;
+    this._graph.hf.setCellContents({ sheet: this.sheetId, row: cell.row, col: cell.col }, [[mappedValue]]);
+  }
+
+  protected override async _open() {
+    // const unsubscribe = this._graph.update.on(this.update.emit);
+    // this._ctx.onDispose(unsubscribe);
+  }
+}

package/src/{components/ComputeGraph → graph}/edge-function.ts

@@ -3,7 +3,6 @@
 //
 
 import { effect } from '@preact/signals-core';
-import { CellError, ErrorType, FunctionArgumentType } from 'hyperformula';
 import { type InterpreterState } from 'hyperformula/typings/interpreter/InterpreterState';
 import { type ProcedureAst } from 'hyperformula/typings/parser';
 
@@ -13,6 +12,7 @@ import { getUserFunctionUrlInMetadata } from '@dxos/plugin-script/edge';
 import { FunctionType } from '@dxos/plugin-script/types';
 import { nonNullable } from '@dxos/util';
 
+import { CellError, ErrorType, FunctionArgumentType } from '#hyperformula';
 import { type AsyncFunction, FunctionPluginAsync } from './async-function';
 
 const EDGE_FUNCTION_TTL = 10_000;
@@ -59,6 +59,7 @@ export class EdgeFunctionPlugin extends FunctionPluginAsync {
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ args: args.filter(nonNullable) }),
         });
+
         return await result.text();
       };
 
@@ -73,8 +74,7 @@ EdgeFunctionPlugin.implementedFunctions = {
       // Binding
       { argumentType: FunctionArgumentType.STRING },
 
-      // Remote function arguments (currently supporting up to 9).
-      { argumentType: FunctionArgumentType.ANY, optionalArg: true },
+      // Remote function arguments (currently supporting up to 8).
       { argumentType: FunctionArgumentType.ANY, optionalArg: true },
       { argumentType: FunctionArgumentType.ANY, optionalArg: true },
       { argumentType: FunctionArgumentType.ANY, optionalArg: true },