@dxos/functions 0.8.4-main.406dc2a → 0.8.4-main.548089c

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.406dc2a",
-  "description": "Functions API and runtime.",
+  "version": "0.8.4-main.548089c",
+  "description": "Functions API.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
@@ -14,37 +14,9 @@
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
-    },
-    "./bundler": {
-      "source": "./src/bundler/index.ts",
-      "types": "./dist/types/src/bundler/index.d.ts",
-      "browser": "./dist/lib/browser/bundler/index.mjs",
-      "node": "./dist/lib/node-esm/bundler/index.mjs"
-    },
-    "./edge": {
-      "source": "./src/edge/index.ts",
-      "types": "./dist/types/src/edge/index.d.ts",
-      "browser": "./dist/lib/browser/edge/index.mjs",
-      "node": "./dist/lib/node-esm/edge/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"
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "bundler": [
-        "dist/types/src/bundler/index.d.ts"
-      ],
-      "edge": [
-        "dist/types/src/edge/index.d.ts"
-      ]
-    }
-  },
   "files": [
     "dist",
     "schema",
@@ -53,35 +25,16 @@
   "dependencies": {
     "@effect/platform": "0.92.1",
     "effect": "3.18.3",
-    "esbuild-wasm": "^0.16.14",
-    "i18next": "^24.2.1",
-    "iso-did": "^1.6.0",
-    "@dxos/ai": "0.8.4-main.406dc2a",
-    "@dxos/async": "0.8.4-main.406dc2a",
-    "@dxos/client": "0.8.4-main.406dc2a",
-    "@dxos/client-protocol": "0.8.4-main.406dc2a",
-    "@dxos/context": "0.8.4-main.406dc2a",
-    "@dxos/crypto": "0.8.4-main.406dc2a",
-    "@dxos/debug": "0.8.4-main.406dc2a",
-    "@dxos/echo-db": "0.8.4-main.406dc2a",
-    "@dxos/echo-protocol": "0.8.4-main.406dc2a",
-    "@dxos/edge-client": "0.8.4-main.406dc2a",
-    "@dxos/echo-pipeline": "0.8.4-main.406dc2a",
-    "@dxos/echo": "0.8.4-main.406dc2a",
-    "@dxos/effect": "0.8.4-main.406dc2a",
-    "@dxos/errors": "0.8.4-main.406dc2a",
-    "@dxos/invariant": "0.8.4-main.406dc2a",
-    "@dxos/keys": "0.8.4-main.406dc2a",
-    "@dxos/kv-store": "0.8.4-main.406dc2a",
-    "@dxos/log": "0.8.4-main.406dc2a",
-    "@dxos/node-std": "0.8.4-main.406dc2a",
-    "@dxos/protocols": "0.8.4-main.406dc2a",
-    "@dxos/live-object": "0.8.4-main.406dc2a",
-    "@dxos/schema": "0.8.4-main.406dc2a",
-    "@dxos/util": "0.8.4-main.406dc2a"
-  },
-  "devDependencies": {
-    "@dxos/agent": "0.8.4-main.406dc2a"
+    "@dxos/ai": "0.8.4-main.548089c",
+    "@dxos/errors": "0.8.4-main.548089c",
+    "@dxos/invariant": "0.8.4-main.548089c",
+    "@dxos/keys": "0.8.4-main.548089c",
+    "@dxos/log": "0.8.4-main.548089c",
+    "@dxos/node-std": "0.8.4-main.548089c",
+    "@dxos/schema": "0.8.4-main.548089c",
+    "@dxos/echo-db": "0.8.4-main.548089c",
+    "@dxos/echo": "0.8.4-main.548089c",
+    "@dxos/types": "0.8.4-main.548089c"
   },
   "publishConfig": {
     "access": "public"

package/src/example/forex-effect.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @ts-ignore
+import { S, defineFunction } from 'dxos:functions';
+import {
+  FetchHttpClient,
+  HttpClient,
+  HttpClientRequest,
+  // @ts-ignore
+} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
+// @ts-ignore
+import { Effect, Schedule } from 'https://esm.sh/effect@3.17.0?bundle=false';
+
+export default defineFunction({
+  key: 'dxos.org/script/forex-effect',
+  name: 'Forex Effect',
+  description: 'Returns the exchange rate between two currencies.',
+
+  inputSchema: S.Struct({
+    from: S.String.annotations({ description: 'The source currency' }),
+    to: S.String.annotations({ description: 'The target currency' }),
+  }),
+
+  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
+
+  handler: async ({ data: { from, to } }: any) =>
+    Effect.gen(function* () {
+      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+        HttpClient.execute,
+        Effect.flatMap((res: any) => res.json),
+        Effect.timeout('1 second'),
+        Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+        Effect.scoped,
+      );
+
+      return res.data.rates[to].toString();
+    }).pipe(Effect.provide(FetchHttpClient.layer)),
+});

package/src/example/index.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { default as fib$ } from './fib';
+import { default as reply$ } from './reply';
+import { default as sleep$ } from './sleep';
+
+export namespace Example {
+  export const fib = fib$;
+  export const reply = reply$;
+  export const sleep = sleep$;
+}

package/src/handler.ts

@@ -2,20 +2,21 @@
 // Copyright 2023 DXOS.org
 //
 
-import type * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
-import type * as Types from 'effect/Types';
 
+import { type AiService } from '@dxos/ai';
 import { Obj, Type } from '@dxos/echo';
-import { type HasId } from '@dxos/echo/internal';
-import { type EchoDatabase } from '@dxos/echo-db';
+import { type DatabaseService } from '@dxos/echo-db';
 import { assertArgument } from '@dxos/invariant';
-import { type DXN, type SpaceId } from '@dxos/keys';
-import { type QueryResult } from '@dxos/protocols';
 
-import { FunctionType } from './schema';
-import { type Services } from './services';
+import {
+  type CredentialsService,
+  type FunctionInvocationService,
+  type QueueService,
+  type TracingService,
+} from './services';
+import { Function } from './types';
 import { getUserFunctionIdInMetadata, setUserFunctionIdInMetadata } from './url';
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
@@ -23,6 +24,22 @@ import { getUserFunctionIdInMetadata, setUserFunctionIdInMetadata } from './url'
 // https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
 // https://www.npmjs.com/package/aws-lambda
 
+/**
+ * Services that are provided at the function call site by the caller.
+ */
+export type InvocationServices = TracingService;
+
+/**
+ * Services that are available to invoked functions.
+ */
+export type FunctionServices =
+  | InvocationServices
+  | AiService.AiService
+  | CredentialsService
+  | DatabaseService
+  | QueueService
+  | FunctionInvocationService;
+
 /**
  * Function handler.
  */
@@ -38,58 +55,15 @@ export type FunctionHandler<TData = {}, TOutput = any> = (params: {
    * This will be the payload from the trigger or other data passed into the function in a workflow.
    */
   data: TData;
-}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, Services>;
+}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, FunctionServices>;
 
 /**
  * Function context.
  */
 export interface FunctionContext {
-  /**
-   * Space from which the function was invoked.
-   */
-  space: SpaceAPI | undefined;
-
-  /**
-   * Resolves a service available to the function.
-   * @throws if the service is not available.
-   */
-  getService: <T extends Context.Tag<any, any>>(tag: T) => Context.Tag.Service<T>;
-
-  getSpace: (spaceId: SpaceId) => Promise<SpaceAPI>;
-}
-
-export interface FunctionContextAi {
-  // TODO(dmaretskyi): Refer to cloudflare AI docs for more comprehensive typedefs.
-  run(model: string, inputs: any, options?: any): Promise<any>;
+  // TODO(dmaretskyi):
 }
 
-//
-// API.
-//
-
-// TODO(dmaretskyi): Temporary API to get the queues working.
-// TODO(dmaretskyi): To be replaced with integrating queues into echo.
-export interface QueuesAPI {
-  queryQueue(queue: DXN, options?: {}): Promise<QueryResult>;
-  insertIntoQueue(queue: DXN, objects: HasId[]): Promise<void>;
-}
-
-/**
- * Space interface available to functions.
- */
-export interface SpaceAPI {
-  get id(): SpaceId;
-  get db(): EchoDatabase;
-
-  // TODO(dmaretskyi): Align with echo api: queues.get(id).append(items);
-  get queues(): QueuesAPI;
-}
-
-// TODO(wittjosiah): Queues are incompatible.
-const __assertFunctionSpaceIsCompatibleWithTheClientSpace = () => {
-  // const _: SpaceAPI = {} as Space;
-};
-
 const typeId = Symbol.for('@dxos/functions/FunctionDefinition');
 
 export type FunctionDefinition<T = any, O = any> = {
@@ -107,23 +81,25 @@ export type FunctionDefinition<T = any, O = any> = {
      * deployedFunctionId:
      * - Backend deployment ID assigned by the EDGE function service (typically a UUID).
      * - Used for remote invocation via `FunctionInvocationService` → `RemoteFunctionExecutionService`.
-     * - Persisted on the corresponding ECHO `FunctionType` object's metadata under the
+     * - Persisted on the corresponding ECHO `Function.Function` object's metadata under the
      *   `FUNCTIONS_META_KEY` and retrieved with `getUserFunctionIdInMetadata`.
      */
     deployedFunctionId?: string;
   };
 };
 
+export type FunctionProps<T, O> = {
+  key: string;
+  name: string;
+  description?: string;
+  inputSchema: Schema.Schema<T, any>;
+  outputSchema?: Schema.Schema<O, any>;
+  handler: FunctionHandler<T, O>;
+};
+
 // TODO(dmaretskyi): Output type doesn't get typechecked.
 export const defineFunction: {
-  <I, O>(params: {
-    key: string;
-    name: string;
-    description?: string;
-    inputSchema: Schema.Schema<I, any>;
-    outputSchema?: Schema.Schema<O, any>;
-    handler: Types.NoInfer<FunctionHandler<I, O>>;
-  }): FunctionDefinition<I, O>;
+  <I, O>(params: FunctionProps<I, O>): FunctionDefinition<I, O>;
 } = ({ key, name, description, inputSchema, outputSchema = Schema.Any, handler }) => {
   if (!Schema.isSchema(inputSchema)) {
     throw new Error('Input schema must be a valid schema');
@@ -169,7 +145,7 @@ export const defineFunction: {
     inputSchema,
     outputSchema,
     handler: handlerWithSpan,
-  };
+  } satisfies FunctionDefinition.Any;
 };
 
 export const FunctionDefinition = {
@@ -177,12 +153,12 @@ export const FunctionDefinition = {
   isFunction: (value: unknown): value is FunctionDefinition.Any => {
     return typeof value === 'object' && value !== null && Symbol.for('@dxos/functions/FunctionDefinition') in value;
   },
-  serialize: (functionDef: FunctionDefinition.Any): FunctionType => {
+  serialize: (functionDef: FunctionDefinition.Any): Function.Function => {
     assertArgument(FunctionDefinition.isFunction(functionDef), 'functionDef');
     return serializeFunction(functionDef);
   },
-  deserialize: (functionObj: FunctionType): FunctionDefinition.Any => {
-    assertArgument(Obj.instanceOf(FunctionType, functionObj), 'functionObj');
+  deserialize: (functionObj: Function.Function): FunctionDefinition.Any => {
+    assertArgument(Obj.instanceOf(Function.Function, functionObj), 'functionObj');
     return deserializeFunction(functionObj);
   },
 };
@@ -192,8 +168,8 @@ export declare namespace FunctionDefinition {
   export type Output<T extends FunctionDefinition> = T extends FunctionDefinition<any, infer O> ? O : never;
 }
 
-export const serializeFunction = (functionDef: FunctionDefinition<any, any>): FunctionType => {
-  const fn = Obj.make(FunctionType, {
+export const serializeFunction = (functionDef: FunctionDefinition<any, any>): Function.Function => {
+  const fn = Function.make({
     key: functionDef.key,
     name: functionDef.name,
     version: '0.1.0',
@@ -207,7 +183,7 @@ export const serializeFunction = (functionDef: FunctionDefinition<any, any>): Fu
   return fn;
 };
 
-export const deserializeFunction = (functionObj: FunctionType): FunctionDefinition<unknown, unknown> => {
+export const deserializeFunction = (functionObj: Function.Function): FunctionDefinition<unknown, unknown> => {
   return {
     [typeId]: true,
     // TODO(dmaretskyi): Fix key.

package/src/index.ts

@@ -3,12 +3,8 @@
 //
 
 export * from './errors';
+export * from './example';
 export * from './handler';
-export * from './schema';
-export * from './trace';
+export * from './services';
 export * from './types';
 export * from './url';
-export * from './triggers';
-export * from './services';
-export * from './executor';
-export * as exampleFunctions from './examples';

package/src/services/credentials.ts

@@ -11,9 +11,8 @@ import * as Layer from 'effect/Layer';
 import * as Redacted from 'effect/Redacted';
 
 import { Query } from '@dxos/echo';
-import { DataType } from '@dxos/schema';
-
-import { DatabaseService } from './database';
+import { DatabaseService } from '@dxos/echo-db';
+import { AccessToken } from '@dxos/types';
 
 export type CredentialQuery = {
   service?: string;
@@ -84,7 +83,7 @@ export class CredentialsService extends Context.Tag('@dxos/functions/Credentials
       Effect.gen(function* () {
         const dbService = yield* DatabaseService;
         const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
-          const { objects: accessTokens } = await dbService.db.query(Query.type(DataType.AccessToken)).run();
+          const { objects: accessTokens } = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
           return accessTokens
             .filter((accessToken) => accessToken.source === query.service)
             .map((accessToken) => ({

package/src/services/event-logger.ts

@@ -17,12 +17,18 @@ export const ComputeEventPayload = Schema.Union(
   Schema.Struct({
     type: Schema.Literal('begin-compute'),
     nodeId: Schema.String,
-    inputs: Schema.Record({ key: Schema.String, value: Schema.Any }),
+    /**
+     * Names of the inputs begin computed.
+     */
+    inputs: Schema.Array(Schema.String),
   }),
   Schema.Struct({
     type: Schema.Literal('end-compute'),
     nodeId: Schema.String,
-    outputs: Schema.Record({ key: Schema.String, value: Schema.Any }),
+    /**
+     * Names of the outputs computed.
+     */
+    outputs: Schema.Array(Schema.String),
   }),
   Schema.Struct({
     type: Schema.Literal('compute-input'),

package/src/services/function-invocation-service.ts

@@ -3,21 +3,8 @@
 //
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
 
-import { AiService } from '@dxos/ai';
-
-import { type FunctionDefinition } from '../handler';
-
-import { CredentialsService } from './credentials';
-import { DatabaseService } from './database';
-import {
-  FunctionImplementationResolver,
-  type InvocationServices,
-  LocalFunctionExecutionService,
-} from './local-function-execution';
-import { QueueService } from './queues';
-import { RemoteFunctionExecutionService } from './remote-function-execution-service';
+import { type FunctionDefinition, type InvocationServices } from '../handler';
 
 export class FunctionInvocationService extends Context.Tag('@dxos/functions/FunctionInvocationService')<
   FunctionInvocationService,
@@ -25,60 +12,9 @@ export class FunctionInvocationService extends Context.Tag('@dxos/functions/Func
     invokeFunction<I, O>(functionDef: FunctionDefinition<I, O>, input: I): Effect.Effect<O, never, InvocationServices>;
   }
 >() {
-  static invokeFunction = Effect.serviceFunctionEffect(FunctionInvocationService, (_) => _.invokeFunction);
-
-  static layer = Layer.effect(
-    FunctionInvocationService,
-    Effect.gen(function* () {
-      const localExecutioner = yield* LocalFunctionExecutionService;
-      const remoteExecutioner = yield* RemoteFunctionExecutionService;
-
-      return {
-        invokeFunction: <I, O>(
-          functionDef: FunctionDefinition<I, O>,
-          input: I,
-        ): Effect.Effect<O, never, InvocationServices> =>
-          Effect.gen(function* () {
-            if (functionDef.meta?.deployedFunctionId) {
-              return yield* remoteExecutioner.callFunction<I, O>(functionDef.meta.deployedFunctionId, input);
-            }
-
-            return yield* localExecutioner.invokeFunction(functionDef, input);
-          }),
-      } satisfies Context.Tag.Service<FunctionInvocationService>;
-    }),
-  );
-
-  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
-  static layerTest = ({
-    functions = [],
-  }: {
-    functions?: FunctionDefinition<any, any>[];
-  } = {}): Layer.Layer<
-    FunctionInvocationService,
-    never,
-    AiService.AiService | CredentialsService | DatabaseService | QueueService
-  > =>
-    FunctionInvocationService.layer.pipe(
-      Layer.provide(LocalFunctionExecutionService.layerLive),
-      Layer.provide(FunctionImplementationResolver.layerTest({ functions })),
-      Layer.provide(RemoteFunctionExecutionService.layerMock),
-    );
-
-  // TODO(dmaretskyi): This shouldn't default to all services being not available.
-  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
-  /**
-   * @deprecated Use {@link layerTest} instead.
-   */
-  static layerTestMocked = ({
-    functions,
-  }: {
-    functions: FunctionDefinition<any, any>[];
-  }): Layer.Layer<FunctionInvocationService> =>
-    FunctionInvocationService.layerTest({ functions }).pipe(
-      Layer.provide(AiService.notAvailable),
-      Layer.provide(CredentialsService.configuredLayer([])),
-      Layer.provide(DatabaseService.notAvailable),
-      Layer.provide(QueueService.notAvailable),
-    );
+  static invokeFunction = <I, O>(
+    functionDef: FunctionDefinition<I, O>,
+    input: I,
+  ): Effect.Effect<O, never, FunctionInvocationService | InvocationServices> =>
+    Effect.serviceFunctionEffect(FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
 }

package/src/services/index.ts

@@ -2,12 +2,12 @@
 // Copyright 2025 DXOS.org
 //
 
+export { DatabaseService } from '@dxos/echo-db';
+
 export * from './credentials';
-export * from './database';
+export { ConfiguredCredentialsService, type ServiceCredential } from './credentials';
 export * from './event-logger';
+export { createEventLogger, createDefectLogger } from './event-logger';
 export * from './function-invocation-service';
-export * from './local-function-execution';
 export * from './queues';
-export * from './service-container';
 export * from './tracing';
-export * from './remote-function-execution-service';

package/src/services/tracing.ts

@@ -9,9 +9,7 @@ import * as Layer from 'effect/Layer';
 import { AgentStatus } from '@dxos/ai';
 import { Obj } from '@dxos/echo';
 import type { ObjectId } from '@dxos/echo/internal';
-import type { Queue } from '@dxos/echo-db';
-import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Message } from '@dxos/types';
 
 /**
  * Provides a way for compute primitives (functions, workflows, tools)
@@ -32,29 +30,12 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
     write: (event: Obj.Any) => void;
   }
 >() {
-  static noop: Context.Tag.Service<TracingService> = { write: () => {}, getTraceContext: () => ({}) };
-
-  static layerNoop = Layer.succeed(TracingService, TracingService.noop);
-
-  static console: Context.Tag.Service<TracingService> = {
-    write: (event) => {
-      console.log(event);
-    },
+  static noop: Context.Tag.Service<TracingService> = {
     getTraceContext: () => ({}),
+    write: () => {},
   };
 
-  static layerConsole = Layer.succeed(TracingService, TracingService.console);
-
-  static layerLogInfo = () =>
-    Layer.succeed(TracingService, {
-      write: (event) => {
-        if (Obj.instanceOf(AgentStatus, event)) {
-          log.info('status', { message: event.message });
-        }
-      },
-      getTraceContext: () => ({}),
-    });
-
+  static layerNoop: Layer.Layer<TracingService> = Layer.succeed(TracingService, TracingService.noop);
   /**
    * Creates a TracingService layer that emits events to the parent tracing service.
    */
@@ -71,22 +52,6 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
       }),
     );
 
-  static layerQueue = (queue: Queue) =>
-    Layer.effect(
-      TracingService,
-      Effect.gen(function* () {
-        // TODO(dmaretskyi): Batching.
-        return {
-          write: (event) => queue.append([event]),
-          getTraceContext: () => ({
-            debugInfo: {
-              queue: queue.dxn.toString(),
-            },
-          }),
-        };
-      }),
-    );
-
   /**
    * Emit the current human-readable execution status.
    */
@@ -105,11 +70,11 @@ export class TracingService extends Context.Tag('@dxos/functions/TracingService'
   });
 
   static emitConverationMessage: (
-    data: Obj.MakeProps<typeof DataType.Message>,
+    data: Obj.MakeProps<typeof Message.Message>,
   ) => Effect.Effect<void, never, TracingService> = Effect.fnUntraced(function* (data) {
     const tracing = yield* TracingService;
     tracing.write(
-      Obj.make(DataType.Message, {
+      Obj.make(Message.Message, {
         parentMessage: tracing.getTraceContext().parentMessage,
         ...data,
         properties: {
@@ -138,6 +103,6 @@ export namespace TracingService {
 }
 
 /**
- * Goes into {@link DataType.Message['properties']}
+ * Goes into {@link Message['properties']}
  */
 export const MESSAGE_PROPERTY_TOOL_CALL_ID = 'toolCallId' as const;

package/src/{schema.ts → types/Function.ts}

@@ -4,36 +4,15 @@
 
 import * as Schema from 'effect/Schema';
 
-import { Type } from '@dxos/echo';
+import { Obj, Type } from '@dxos/echo';
 import { JsonSchemaType, LabelAnnotation, Ref } from '@dxos/echo/internal';
-import { DataType } from '@dxos/schema';
 
-// TODO(burdon): Create namespace and remove Type suffix.
-
-/**
- * Source script.
- */
-export const ScriptType = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String),
-  // TODO(burdon): Change to hash of deployed content.
-  // Whether source has changed since last deploy.
-  changed: Schema.optional(Schema.Boolean),
-  source: Ref(DataType.Text),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Script',
-    version: '0.1.0',
-  }),
-  LabelAnnotation.set(['name']),
-);
-
-export interface ScriptType extends Schema.Schema.Type<typeof ScriptType> {}
+import { Script } from './Script';
 
 /**
  * Function deployment.
  */
-export const FunctionType = Schema.Struct({
+export const Function = Schema.Struct({
   /**
    * Global registry ID.
    * NOTE: The `key` property refers to the original registry entry.
@@ -51,9 +30,14 @@ export const FunctionType = Schema.Struct({
 
   description: Schema.optional(Schema.String),
 
+  /**
+   * ISO date string of the last deployment.
+   */
+  updated: Schema.optional(Schema.String),
+
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema.optional(Ref(ScriptType)),
+  source: Schema.optional(Ref(Script)),
 
   inputSchema: Schema.optional(JsonSchemaType),
   outputSchema: Schema.optional(JsonSchemaType),
@@ -67,5 +51,6 @@ export const FunctionType = Schema.Struct({
   }),
   LabelAnnotation.set(['name']),
 );
+export interface Function extends Schema.Schema.Type<typeof Function> {}
 
-export interface FunctionType extends Schema.Schema.Type<typeof FunctionType> {}
+export const make = (props: Obj.MakeProps<typeof Function>) => Obj.make(Function, props);