@dxos/functions 0.8.1 → 0.8.2-main.2f9c567

package/dist/types/src/types/trace.d.ts

@@ -1,146 +0,0 @@
-import { Expando, Ref, S } from '@dxos/echo-schema';
-import { type FunctionTriggerType } from './types';
-export declare enum InvocationOutcome {
-    SUCCESS = "success",
-    FAILURE = "failure",
-    PENDING = "pending"
-}
-export declare enum InvocationTraceEventType {
-    START = "start",
-    END = "end"
-}
-export declare const TraceEventException: S.Struct<{
-    timestampMs: typeof S.Number;
-    message: typeof S.String;
-    name: typeof S.String;
-    stack: S.optional<typeof S.String>;
-}>;
-export type TraceEventException = S.Schema.Type<typeof TraceEventException>;
-export declare const InvocationTraceStartEvent: import("@dxos/echo-schema").EchoObjectSchema<S.Struct<{
-    /**
-     * Queue message id.
-     */
-    id: import("@dxos/echo-schema").ObjectIdClass;
-    type: S.Literal<[InvocationTraceEventType.START]>;
-    /**
-     * Invocation id, the same for invocation start and end events.
-     */
-    invocationId: import("@dxos/echo-schema").ObjectIdClass;
-    /**
-     * Event generation time.
-     */
-    timestampMs: typeof S.Number;
-    /**
-     * Data passed to function / workflow as an argument.
-     */
-    input: typeof S.Object;
-    /**
-     * Queue DXN for function/workflow invocation events.
-     */
-    invocationTraceQueue: import("@dxos/echo-schema").Ref$<Expando>;
-    /**
-     * DXN of the invoked function/workflow.
-     */
-    invocationTarget: import("@dxos/echo-schema").Ref$<Expando>;
-    /**
-     * Present for automatic invocations.
-     */
-    trigger: S.optional<import("@dxos/echo-schema").Ref$<import("@dxos/echo-schema").TypedObjectFields<{
-        readonly function: S.optional<S.SchemaClass<string, string, never>>;
-        readonly enabled: S.optional<S.SchemaClass<boolean, boolean, never>>;
-        readonly spec: S.optional<S.Union<[S.mutable<S.Struct<{
-            type: S.Literal<[import("./types").TriggerKind.Timer]>;
-            cron: S.SchemaClass<string, string, never>;
-        }>>, S.mutable<S.Struct<{
-            type: S.Literal<[import("./types").TriggerKind.Webhook]>;
-            method: S.optional<S.SchemaClass<string, string, never>>;
-            port: S.optional<S.SchemaClass<number, number, never>>;
-        }>>, S.mutable<S.Struct<{
-            type: S.Literal<[import("./types").TriggerKind.Subscription]>;
-            filter: S.Struct<{
-                type: S.optional<S.SchemaClass<string, string, never>>;
-                props: S.optional<S.Record$<typeof S.String, typeof S.Any>>;
-            }>;
-            options: S.optional<S.Struct<{
-                deep: S.optional<S.SchemaClass<boolean, boolean, never>>;
-                delay: S.optional<S.SchemaClass<number, number, never>>;
-            }>>;
-        }>>, S.mutable<S.Struct<{
-            type: S.Literal<[import("./types").TriggerKind.Email]>;
-        }>>, S.mutable<S.Struct<{
-            type: S.Literal<[import("./types").TriggerKind.Queue]>;
-            queue: S.refine<string, typeof S.NonEmptyString>;
-        }>>]>>;
-        readonly meta: S.optional<S.mutable<S.Record$<typeof S.String, typeof S.Any>>>;
-    }, import("@dxos/echo-schema").TypedObjectOptions>>>;
-}>>;
-export type InvocationTraceStartEvent = S.Schema.Type<typeof InvocationTraceStartEvent>;
-export declare const InvocationTraceEndEvent: import("@dxos/echo-schema").EchoObjectSchema<S.Struct<{
-    /**
-     * Trace event id.
-     */
-    id: import("@dxos/echo-schema").ObjectIdClass;
-    type: S.Literal<[InvocationTraceEventType.END]>;
-    /**
-     * Invocation id, will be the same for invocation start and end.
-     */
-    invocationId: import("@dxos/echo-schema").ObjectIdClass;
-    /**
-     * Event generation time.
-     */
-    timestampMs: typeof S.Number;
-    outcome: S.Enums<typeof InvocationOutcome>;
-    exception: S.optional<S.Struct<{
-        timestampMs: typeof S.Number;
-        message: typeof S.String;
-        name: typeof S.String;
-        stack: S.optional<typeof S.String>;
-    }>>;
-}>>;
-export type InvocationTraceEndEvent = S.Schema.Type<typeof InvocationTraceEndEvent>;
-export type InvocationTraceEvent = InvocationTraceStartEvent | InvocationTraceEndEvent;
-export declare const TraceEventLog: S.Struct<{
-    timestampMs: typeof S.Number;
-    level: typeof S.String;
-    message: typeof S.String;
-    context: S.optional<typeof S.Object>;
-}>;
-export declare const TraceEvent: import("@dxos/echo-schema").EchoObjectSchema<S.Struct<{
-    id: import("@dxos/echo-schema").ObjectIdClass;
-    outcome: typeof S.String;
-    truncated: typeof S.Boolean;
-    /**
-     * Time when the event was persisted.
-     */
-    ingestionTimestampMs: typeof S.Number;
-    logs: S.Array$<S.Struct<{
-        timestampMs: typeof S.Number;
-        level: typeof S.String;
-        message: typeof S.String;
-        context: S.optional<typeof S.Object>;
-    }>>;
-    exceptions: S.Array$<S.Struct<{
-        timestampMs: typeof S.Number;
-        message: typeof S.String;
-        name: typeof S.String;
-        stack: S.optional<typeof S.String>;
-    }>>;
-}>>;
-export type TraceEvent = S.Schema.Type<typeof TraceEvent>;
-/**
- * Deprecated InvocationTrace event format.
- * @deprecated
- */
-export type InvocationSpan = {
-    id: string;
-    timestampMs: number;
-    outcome: InvocationOutcome;
-    input: object;
-    durationMs: number;
-    invocationTraceQueue: Ref<Expando>;
-    invocationTarget: Ref<Expando>;
-    trigger?: Ref<FunctionTriggerType>;
-    exception?: TraceEventException;
-};
-export declare const createInvocationSpans: (items?: InvocationTraceEvent[]) => InvocationSpan[];
-//# sourceMappingURL=trace.d.ts.map

package/dist/types/src/types/trace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../../../src/types/trace.ts"],"names":[],"mappings":"AAIA,OAAO,EAAc,OAAO,EAAY,GAAG,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,EAAmB,KAAK,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEpE,oBAAY,iBAAiB;IAC3B,OAAO,YAAY;IACnB,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAGD,oBAAY,wBAAwB;IAClC,KAAK,UAAU;IACf,GAAG,QAAQ;CACZ;AAED,eAAO,MAAM,mBAAmB;;;;;EAK9B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAE5E,eAAO,MAAM,yBAAyB;IACpC;;OAEG;;;IAGH;;OAEG;;IAEH;;OAEG;;IAEH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEoF,CAAC;AAE1F,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAExF,eAAO,MAAM,uBAAuB;IAClC;;OAEG;;;IAGH;;OAEG;;IAEH;;OAEG;;;;;;;;;GAKkF,CAAC;AAExF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEpF,MAAM,MAAM,oBAAoB,GAAG,yBAAyB,GAAG,uBAAuB,CAAC;AAEvF,eAAO,MAAM,aAAa;;;;;EAKxB,CAAC;AAEH,eAAO,MAAM,UAAU;;;;IAKrB;;OAEG;;;;;;;;;;;;;;GAI0E,CAAC;AAEhF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC;AAE1D;;;GAGG;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IACnC,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,GAAG,CAAC,mBAAmB,CAAC,CAAC;IACnC,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,qBAAqB,WAAY,oBAAoB,EAAE,KAAG,cAAc,EAkDpF,CAAC"}

package/dist/types/src/types/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/types/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAuC,CAAC,EAAoB,MAAM,mBAAmB,CAAC;AAE7F;;;;GAIG;AACH,oBAAY,WAAW;IACrB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,YAAY,iBAAiB;IAC7B,KAAK,UAAU;IACf,KAAK,UAAU;CAChB;AAKD;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;GAMN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,kBAAkB;;GAEN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,kBAAkB;;;GAGN,CAAC;AAEnB,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;GAaR,CAAC;AAEnB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAQxE;;GAEG;AACH,QAAA,MAAM,yBAAyB;;;;;;;;;;GAYb,CAAC;AAEnB,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;KAQxB,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAchC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9E;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBAGL;CAAG;;;;;;;;;;;;AAEnC;;;GAGG;AAEH,qBAAa,WAAY,SAAQ,gBAQ/B;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,cAAc,iDAAiC,CAAC"}

package/dist/types/src/types/url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../../src/types/url.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AAK1C,eAAO,MAAM,yBAAyB,qCAAqC,CAAC;AAM5E,eAAO,MAAM,4BAA4B,SAAU,UAAU,uBAE5D,CAAC;AAEF,eAAO,MAAM,4BAA4B,SAAU,UAAU,eAAe,MAAM,SASjF,CAAC;AAEF,eAAO,MAAM,gBAAgB,gBAAiB,MAAM,WAAW,MAAM,YAAW,iBAAiB,WAUhG,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/dist/types/tools/schema.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=schema.d.ts.map

package/dist/types/tools/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../tools/schema.ts"],"names":[],"mappings":""}

package/schema/functions.json

@@ -1,211 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "type": "object",
-  "required": [],
-  "properties": {
-    "functions": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": [
-          "uri",
-          "route",
-          "handler"
-        ],
-        "properties": {
-          "uri": {
-            "type": "string",
-            "description": "a string",
-            "title": "string"
-          },
-          "route": {
-            "type": "string",
-            "description": "a string",
-            "title": "string"
-          },
-          "handler": {
-            "type": "string",
-            "description": "a string",
-            "title": "string"
-          },
-          "description": {
-            "type": "string",
-            "description": "a string",
-            "title": "string"
-          }
-        },
-        "additionalProperties": false
-      }
-    },
-    "triggers": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "required": [
-          "function",
-          "spec"
-        ],
-        "properties": {
-          "function": {
-            "type": "string",
-            "description": "Function",
-            "title": "string"
-          },
-          "enabled": {
-            "type": "boolean",
-            "description": "a boolean",
-            "title": "boolean"
-          },
-          "meta": {
-            "$ref": "#/$defs/object"
-          },
-          "spec": {
-            "anyOf": [
-              {
-                "type": "object",
-                "required": [
-                  "type",
-                  "cron"
-                ],
-                "properties": {
-                  "type": {
-                    "const": "timer"
-                  },
-                  "cron": {
-                    "type": "string",
-                    "description": "a string",
-                    "title": "string"
-                  }
-                },
-                "additionalProperties": false
-              },
-              {
-                "type": "object",
-                "required": [
-                  "type",
-                  "method"
-                ],
-                "properties": {
-                  "type": {
-                    "const": "webhook"
-                  },
-                  "method": {
-                    "type": "string",
-                    "description": "a string",
-                    "title": "string"
-                  },
-                  "port": {
-                    "type": "number",
-                    "description": "a number",
-                    "title": "number"
-                  }
-                },
-                "additionalProperties": false
-              },
-              {
-                "type": "object",
-                "required": [
-                  "type",
-                  "url"
-                ],
-                "properties": {
-                  "type": {
-                    "const": "websocket"
-                  },
-                  "url": {
-                    "type": "string",
-                    "description": "a string",
-                    "title": "string"
-                  },
-                  "init": {
-                    "type": "object",
-                    "required": [],
-                    "properties": {},
-                    "additionalProperties": {
-                      "$id": "/schemas/any",
-                      "title": "any"
-                    }
-                  }
-                },
-                "additionalProperties": false
-              },
-              {
-                "type": "object",
-                "required": [
-                  "type",
-                  "filter"
-                ],
-                "properties": {
-                  "type": {
-                    "const": "subscription"
-                  },
-                  "filter": {
-                    "type": "array",
-                    "items": {
-                      "type": "object",
-                      "required": [
-                        "type"
-                      ],
-                      "properties": {
-                        "type": {
-                          "type": "string",
-                          "description": "a string",
-                          "title": "string"
-                        },
-                        "props": {
-                          "type": "object",
-                          "required": [],
-                          "properties": {},
-                          "additionalProperties": {
-                            "$id": "/schemas/any",
-                            "title": "any"
-                          }
-                        }
-                      },
-                      "additionalProperties": false
-                    }
-                  },
-                  "options": {
-                    "type": "object",
-                    "required": [],
-                    "properties": {
-                      "deep": {
-                        "type": "boolean",
-                        "description": "a boolean",
-                        "title": "boolean"
-                      },
-                      "delay": {
-                        "type": "number",
-                        "description": "a number",
-                        "title": "number"
-                      }
-                    },
-                    "additionalProperties": false
-                  }
-                },
-                "additionalProperties": false
-              }
-            ]
-          }
-        },
-        "additionalProperties": false
-      }
-    }
-  },
-  "additionalProperties": false,
-  "$defs": {
-    "object": {
-      "$id": "/schemas/object",
-      "oneOf": [
-        {
-          "type": "object"
-        },
-        {
-          "type": "array"
-        }
-      ],
-      "description": "an object in the TypeScript meaning, i.e. the `object` type",
-      "title": "object"
-    }
-  }
-}

package/src/browser/index.ts

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

package/src/function/function-registry.test.ts

@@ -1,118 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-
-import { Trigger } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { TestBuilder } from '@dxos/client/testing';
-import { Context } from '@dxos/context';
-import { Filter } from '@dxos/echo-db';
-import { create } from '@dxos/live-object';
-import { range } from '@dxos/util';
-
-import { FunctionRegistry } from './function-registry';
-import { createInitializedClients } from '../testing';
-import { FunctionDef, type FunctionManifest } from '../types';
-
-const testManifest: FunctionManifest = {
-  functions: [
-    {
-      uri: 'dxos.functions.test/hello',
-      route: '/hello',
-      handler: 'test',
-    },
-  ],
-};
-
-describe('function registry', () => {
-  let ctx: Context;
-  let testBuilder: TestBuilder;
-
-  beforeEach(async () => {
-    ctx = new Context();
-    testBuilder = new TestBuilder();
-  });
-
-  afterEach(async () => {
-    await ctx.dispose();
-    await testBuilder.destroy();
-  });
-
-  test('getUniqueByUri', async () => {
-    const client = (await createInitializedClients(testBuilder))[0];
-    const registry = createRegistry(client);
-    await registry.open();
-    for (let i = 0; i < 2; i++) {
-      const space = await client.spaces.create();
-      await registry.register(space, testManifest.functions);
-    }
-    const definitions = registry.getUniqueByUri();
-    expect(definitions.length).to.eq(testManifest.functions?.length);
-  });
-
-  describe('register', () => {
-    test('creates new functions', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      await registry.register(space, testManifest.functions);
-      const { objects: definitions } = await space.db.query(Filter.schema(FunctionDef)).run();
-      expect(definitions.length).to.eq(1);
-      expect(definitions[0].uri).to.eq(testManifest.functions?.[0]?.uri);
-    });
-
-    test('de-duplicates by function URI', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      const existing = space.db.add(create(FunctionDef, testManifest.functions![0]));
-      await registry.register(space, testManifest.functions);
-      const { objects: definitions } = await space.db.query(Filter.schema(FunctionDef)).run();
-      expect(definitions.length).to.eq(1);
-      expect(definitions[0].uri).to.eq(existing.uri);
-    });
-  });
-
-  describe('onFunctionsRegistered', () => {
-    test('called with all registered when opened', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-      const definitions = range(3, () => create(FunctionDef, testManifest.functions![0]));
-      definitions.forEach((def) => space.db.add(def));
-
-      const functionRegistered = new Trigger<FunctionDef[]>();
-      registry.registered.on((fn) => {
-        functionRegistered.wake(fn.added);
-      });
-      void registry.open(ctx);
-      const functions = await functionRegistered.wait();
-      const expected = definitions.map((def) => def.uri).sort();
-      expect(functions.map((fn) => fn.uri).sort()).to.deep.eq(expected);
-    });
-
-    test('called when a new functions is added', async () => {
-      const client = (await createInitializedClients(testBuilder))[0];
-      const registry = createRegistry(client);
-      const space = await client.spaces.create();
-
-      const functionRegistered = new Trigger<FunctionDef>();
-      registry.registered.on((fn) => {
-        expect(fn.added.length).to.eq(1);
-        functionRegistered.wake(fn.added[0]);
-      });
-      await registry.open(ctx);
-      await registry.register(space, testManifest.functions);
-      const registered = await functionRegistered.wait();
-      expect(registered.uri).to.eq(testManifest.functions![0].uri);
-    });
-  });
-
-  const createRegistry = (client: Client) => {
-    const registry = new FunctionRegistry(client);
-    ctx.onDispose(() => registry.close());
-    return registry;
-  };
-});

package/src/function/function-registry.ts

@@ -1,104 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Event } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { create, Filter, type Space } from '@dxos/client/echo';
-import { type Context, Resource } from '@dxos/context';
-import { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { ComplexMap, diff } from '@dxos/util';
-
-import { FunctionDef, type FunctionManifest } from '../types';
-
-export type FunctionsRegisteredEvent = {
-  space: Space;
-  added: FunctionDef[];
-};
-
-export class FunctionRegistry extends Resource {
-  private readonly _functionBySpaceKey = new ComplexMap<PublicKey, FunctionDef[]>(PublicKey.hash);
-
-  public readonly registered = new Event<FunctionsRegisteredEvent>();
-
-  constructor(private readonly _client: Client) {
-    super();
-  }
-
-  public getFunctions(space: Space): FunctionDef[] {
-    return this._functionBySpaceKey.get(space.key) ?? [];
-  }
-
-  public getUniqueByUri(): FunctionDef[] {
-    const uniqueByUri = [...this._functionBySpaceKey.values()]
-      .flatMap((defs) => defs)
-      .reduce((acc, v) => {
-        acc.set(v.uri, v);
-        return acc;
-      }, new Map<string, FunctionDef>());
-    return [...uniqueByUri.values()];
-  }
-
-  /**
-   * Loads function definitions from the manifest into the space.
-   * We first load all the definitions from the space to deduplicate by functionId.
-   */
-  public async register(space: Space, functions: FunctionManifest['functions']): Promise<void> {
-    log('register', { space: space.key, functions: functions?.length ?? 0 });
-    if (!functions?.length) {
-      return;
-    }
-    if (!space.db.graph.schemaRegistry.hasSchema(FunctionDef)) {
-      space.db.graph.schemaRegistry.addSchema([FunctionDef]);
-    }
-
-    // Sync definitions.
-    const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
-    const { added } = diff(existing, functions, (a, b) => a.uri === b.uri);
-    // TODO(burdon): Update existing templates.
-    added.forEach((def) => space.db.add(create(FunctionDef, def)));
-
-    if (added.length > 0) {
-      await space.db.flush({ indexes: true, updates: true });
-    }
-  }
-
-  protected override async _open(): Promise<void> {
-    log.info('opening...');
-    const spacesSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._functionBySpaceKey.has(space.key)) {
-          continue;
-        }
-
-        const registered: FunctionDef[] = [];
-        this._functionBySpaceKey.set(space.key, registered);
-        await space.waitUntilReady();
-        if (this._ctx.disposed) {
-          break;
-        }
-
-        // Subscribe to updates.
-        this._ctx.onDispose(
-          space.db.query(Filter.schema(FunctionDef)).subscribe(({ objects }) => {
-            const { added } = diff(registered, objects, (a, b) => a.uri === b.uri);
-            // TODO(burdon): Update and remove.
-            if (added.length > 0) {
-              registered.push(...added);
-              this.registered.emit({ space, added });
-            }
-          }),
-        );
-      }
-    });
-
-    // TODO(burdon): API: Normalize unsubscribe methods.
-    this._ctx.onDispose(() => spacesSubscription.unsubscribe());
-  }
-
-  protected override async _close(_: Context): Promise<void> {
-    log.info('closing...');
-    this._functionBySpaceKey.clear();
-  }
-}

package/src/function/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './function-registry';