@dxos/compute 0.8.4-main.c85a9c8dae → 0.8.4-main.cb12b3f963

package/README.md

@@ -1,3 +1,38 @@
 # @dxos/compute
 
-Basic compute API.
+Umbrella package for AI-aware DXOS compute primitives.
+
+## Usage
+
+Importing from `@dxos/compute` is equivalent to importing from the underlying
+source packages. Namespaces preserve their nesting — there is no extra wrapping
+or unwrapping:
+
+```ts
+import { Blueprint, Operation, Routine, Process, Script, Trace, Trigger } from '@dxos/compute';
+
+Blueprint.make({ /* ... */ });
+Operation.lazy(() => /* ... */);
+Trace.write(Trace.OperationStart, { /* ... */ });
+```
+
+This single surface subsumes:
+
+| Re-exported from   | Includes                                                        |
+| ------------------ | --------------------------------------------------------------- |
+| `@dxos/operation`  | `Operation`, `OperationInvoker`, `OperationHandlerSet`, `OperationRegistry`, errors |
+| `@dxos/blueprints` | `Blueprint`, `Routine`, `Template`                              |
+| `@dxos/functions`  | `Process`, `Trigger`, `TriggerEvent`, `Script`, `Trace`, `ServiceResolver`, `StorageService`, `CredentialsService`, `ExampleHandlers`, services, errors, sdk |
+
+The HyperFormula-based compute graph that previously lived here moved to
+[`@dxos/compute-hyperformula`](../compute-hyperformula).
+
+## Roadmap
+
+- Stage 1 (current): re-exports — consumers depend only on `@dxos/compute`
+  while the source packages stay in place.
+- Stage 2: migrate source into `@dxos/compute` and remove
+  `@dxos/operation`, `@dxos/blueprints`, and `@dxos/functions`.
+- A companion `@dxos/compute-runtime-local` package will host the local
+  implementations of the services defined here (currently in
+  `@dxos/functions-runtime`).

package/dist/lib/neutral/StorageService.mjs

@@ -0,0 +1,22 @@
+import {
+  StorageService,
+  clear,
+  deleteKey,
+  get,
+  key,
+  list,
+  set,
+  withDefault
+} from "./chunk-DDEBBRCI.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  StorageService,
+  clear,
+  deleteKey,
+  get,
+  key,
+  list,
+  set,
+  withDefault
+};
+//# sourceMappingURL=StorageService.mjs.map

package/dist/lib/neutral/StorageService.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/chunk-4N4JAXCP.mjs

@@ -0,0 +1,17 @@
+import {
+  Sleep
+} from "./chunk-S24LL2D5.mjs";
+import {
+  withHandler
+} from "./chunk-QPCDM7MF.mjs";
+
+// src/testing/sleep.ts
+import * as Effect from "effect/Effect";
+var sleep_default = Sleep.pipe(withHandler(Effect.fn(function* ({ duration = 1e5 }) {
+  yield* Effect.sleep(duration);
+})));
+
+export {
+  sleep_default
+};
+//# sourceMappingURL=chunk-4N4JAXCP.mjs.map

package/dist/lib/neutral/chunk-4N4JAXCP.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/testing/sleep.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport * as Operation from '../Operation';\nimport { Sleep } from './definitions';\n\nexport default Sleep.pipe(\n  Operation.withHandler(\n    Effect.fn(function* ({ duration = 100_000 }) {\n      yield* Effect.sleep(duration);\n    }),\n  ),\n);\n"],
+  "mappings": ";;;;;;;;AAIA,YAAYA,YAAY;AAKxB,IAAA,gBAAeC,MAAMC,KACTC,YACDC,UAAG,WAAW,EAAEC,WAAW,IAAO,GAAE;AACzC,SAAcC,aAAMD,QAAAA;AACtB,CAAA,CAAA,CAAA;",
+  "names": ["Effect", "Sleep", "pipe", "withHandler", "fn", "duration", "sleep"]
+}

package/dist/lib/neutral/chunk-DDEBBRCI.mjs

@@ -0,0 +1,62 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/StorageService.ts
+var StorageService_exports = {};
+__export(StorageService_exports, {
+  StorageService: () => StorageService,
+  clear: () => clear,
+  deleteKey: () => deleteKey,
+  get: () => get,
+  key: () => key,
+  list: () => list,
+  set: () => set,
+  withDefault: () => withDefault
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Pipeable from "effect/Pipeable";
+var StorageService = class extends Context.Tag("@dxos/functions/StorageService")() {
+};
+var get = Effect.serviceFunctionEffect(StorageService, (_) => _.get);
+var set = Effect.serviceFunctionEffect(StorageService, (_) => _.set);
+var deleteKey = Effect.serviceFunctionEffect(StorageService, (_) => _.delete);
+var list = Effect.serviceFunctionEffect(StorageService, (_) => _.list);
+var clear = Effect.serviceFunctionEffect(StorageService, (_) => _.clear);
+var key = (schema, key2) => {
+  return {
+    key: key2,
+    get: get(schema, key2),
+    set: (value) => set(schema, key2, value),
+    delete: () => deleteKey(key2),
+    pipe(...args) {
+      return Pipeable.pipeArguments(this, arguments);
+    }
+  };
+};
+var withDefault = (getDefault) => (key2) => {
+  return {
+    key: key2.key,
+    get: key2.get.pipe(Effect.map(Option.getOrElse(() => getDefault()))),
+    set: (value) => key2.set(value),
+    delete: () => key2.delete(),
+    pipe(...args) {
+      return Pipeable.pipeArguments(this, arguments);
+    }
+  };
+};
+
+export {
+  StorageService,
+  get,
+  set,
+  deleteKey,
+  list,
+  clear,
+  key,
+  withDefault,
+  StorageService_exports
+};
+//# sourceMappingURL=chunk-DDEBBRCI.mjs.map

package/dist/lib/neutral/chunk-DDEBBRCI.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/StorageService.ts"],
+  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\n\nexport interface Service {\n  /** Read a value by key. Returns `None` if key does not exist. */\n  get<S extends Schema.Schema<any, string, any>>(\n    schema: S,\n    key: string,\n  ): Effect.Effect<Option.Option<Schema.Schema.Type<S>>, never, Schema.Schema.Context<S>>;\n\n  /** Write a value for the given key. */\n  set<S extends Schema.Schema<any, string, any>>(\n    schema: S,\n    key: string,\n    value: Schema.Schema.Type<S>,\n  ): Effect.Effect<void, never, Schema.Schema.Context<S>>;\n\n  /** Remove a key. */\n  delete(key: string): Effect.Effect<void>;\n\n  /** List all keys, optionally filtered by prefix. */\n  list(prefix?: string): Effect.Effect<readonly string[]>;\n\n  /** Remove all keys managed by this scoped store. */\n  clear(): Effect.Effect<void>;\n}\n\n/**\n * Scoped key-value storage service for processes.\n * Each process receives its own namespaced instance via the process manager.\n * Construct a live implementation with `StorageService.layer` from `@dxos/functions-runtime`.\n */\nexport class StorageService extends Context.Tag('@dxos/functions/StorageService')<StorageService, Service>() {}\n\nexport const get = Effect.serviceFunctionEffect(StorageService, (_) => _.get);\nexport const set = Effect.serviceFunctionEffect(StorageService, (_) => _.set);\nexport const deleteKey = Effect.serviceFunctionEffect(StorageService, (_) => _.delete);\nexport const list = Effect.serviceFunctionEffect(StorageService, (_) => _.list);\nexport const clear = Effect.serviceFunctionEffect(StorageService, (_) => _.clear);\n\n/**\n * Typed key in a storage service.\n */\nexport interface Key<T> extends Pipeable.Pipeable {\n  readonly key: string;\n\n  get: Effect.Effect<Option.Option<T>, never, StorageService>;\n  set(value: T): Effect.Effect<void, never, StorageService>;\n  delete(): Effect.Effect<void, never, StorageService>;\n}\n\n/**\n * Create a typed key in a storage service.\n */\nexport const key = <S extends Schema.Schema<any, string, any>>(schema: S, key: string): Key<Schema.Schema.Type<S>> => {\n  return {\n    key,\n    get: get(schema, key),\n    set: (value: Schema.Schema.Type<S>) => set(schema, key, value),\n    delete: () => deleteKey(key),\n    pipe(...args: any) {\n      return Pipeable.pipeArguments(this, arguments);\n    },\n  };\n};\n\n/**\n * Typed key in a storage service with a default value.\n */\nexport interface KeyWithDefault<T, U> extends Pipeable.Pipeable {\n  readonly key: string;\n  get: Effect.Effect<T | U, never, StorageService>;\n  set(value: U): Effect.Effect<void, never, StorageService>;\n  delete(): Effect.Effect<void, never, StorageService>;\n}\n\n/**\n * Assign a default value to a key if it is not present.\n */\nexport const withDefault =\n  <T>(getDefault: () => NoInfer<T>) =>\n  (key: Key<T>): KeyWithDefault<T, T> => {\n    return {\n      key: key.key,\n      get: key.get.pipe(Effect.map(Option.getOrElse(() => getDefault()))),\n      set: (value) => key.set(value),\n      delete: () => key.delete(),\n      pipe(...args: any) {\n        return Pipeable.pipeArguments(this, arguments);\n      },\n    };\n  };\n"],
+  "mappings": ";;;;;AAAA;;;;;;;;;;;AAIA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,YAAY;AACxB,YAAYC,cAAc;AAgCnB,IAAMC,iBAAN,cAAqCC,YAAI,gCAAA,EAAA,EAAA;AAA8D;AAEvG,IAAMC,MAAaC,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEF,GAAG;AACrE,IAAMG,MAAaF,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEC,GAAG;AACrE,IAAMC,YAAmBH,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEG,MAAM;AAC9E,IAAMC,OAAcL,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEI,IAAI;AACvE,IAAMC,QAAeN,6BAAsBH,gBAAgB,CAACI,MAAMA,EAAEK,KAAK;AAgBzE,IAAMC,MAAM,CAA4CC,QAAWD,SAAAA;AACxE,SAAO;IACLA,KAAAA;IACAR,KAAKA,IAAIS,QAAQD,IAAAA;IACjBL,KAAK,CAACO,UAAiCP,IAAIM,QAAQD,MAAKE,KAAAA;IACxDL,QAAQ,MAAMD,UAAUI,IAAAA;IACxBG,QAAQC,MAAS;AACf,aAAgBC,uBAAc,MAAMC,SAAAA;IACtC;EACF;AACF;AAeO,IAAMC,cACX,CAAIC,eACJ,CAACR,SAAAA;AACC,SAAO;IACLA,KAAKA,KAAIA;IACTR,KAAKQ,KAAIR,IAAIW,KAAYM,WAAWC,iBAAU,MAAMF,WAAAA,CAAAA,CAAAA,CAAAA;IACpDb,KAAK,CAACO,UAAUF,KAAIL,IAAIO,KAAAA;IACxBL,QAAQ,MAAMG,KAAIH,OAAM;IACxBM,QAAQC,MAAS;AACf,aAAgBC,uBAAc,MAAMC,SAAAA;IACtC;EACF;AACF;",
+  "names": ["Context", "Effect", "Option", "Pipeable", "StorageService", "Tag", "get", "serviceFunctionEffect", "_", "set", "deleteKey", "delete", "list", "clear", "key", "schema", "value", "pipe", "args", "pipeArguments", "arguments", "withDefault", "getDefault", "map", "getOrElse"]
+}

package/dist/lib/neutral/chunk-FEABF5XY.mjs

@@ -0,0 +1,25 @@
+import {
+  Fibonacci
+} from "./chunk-S24LL2D5.mjs";
+import {
+  withHandler
+} from "./chunk-QPCDM7MF.mjs";
+
+// src/testing/fib.ts
+import * as Effect from "effect/Effect";
+var fib_default = Fibonacci.pipe(withHandler(Effect.fn(function* ({ iterations = 1e5 }) {
+  let a = 0n;
+  let b = 1n;
+  for (let i = 0; i < iterations; i++) {
+    a += b;
+    b = a - b;
+  }
+  return {
+    result: a.toString()
+  };
+})));
+
+export {
+  fib_default
+};
+//# sourceMappingURL=chunk-FEABF5XY.mjs.map

package/dist/lib/neutral/chunk-FEABF5XY.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/testing/fib.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\n\nimport * as Operation from '../Operation';\nimport { Fibonacci } from './definitions';\n\nexport default Fibonacci.pipe(\n  Operation.withHandler(\n    Effect.fn(function* ({ iterations = 100_000 }) {\n      let a = 0n;\n      let b = 1n;\n      for (let i = 0; i < iterations; i++) {\n        a += b;\n        b = a - b;\n      }\n      return { result: a.toString() };\n    }),\n  ),\n);\n"],
+  "mappings": ";;;;;;;;AAIA,YAAYA,YAAY;AAKxB,IAAA,cAAeC,UAAUC,KACbC,YACDC,UAAG,WAAW,EAAEC,aAAa,IAAO,GAAE;AAC3C,MAAIC,IAAI;AACR,MAAIC,IAAI;AACR,WAASC,IAAI,GAAGA,IAAIH,YAAYG,KAAK;AACnCF,SAAKC;AACLA,QAAID,IAAIC;EACV;AACA,SAAO;IAAEE,QAAQH,EAAEI,SAAQ;EAAG;AAChC,CAAA,CAAA,CAAA;",
+  "names": ["Effect", "Fibonacci", "pipe", "withHandler", "fn", "iterations", "a", "b", "i", "result", "toString"]
+}

package/dist/lib/neutral/chunk-H6EHIVDN.mjs

@@ -0,0 +1,21 @@
+import {
+  Reply
+} from "./chunk-S24LL2D5.mjs";
+import {
+  withHandler
+} from "./chunk-QPCDM7MF.mjs";
+
+// src/testing/reply.ts
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+var reply_default = Reply.pipe(withHandler(Effect.fn(function* (input) {
+  yield* Console.log("reply", {
+    input
+  });
+  return input;
+})));
+
+export {
+  reply_default
+};
+//# sourceMappingURL=chunk-H6EHIVDN.mjs.map

package/dist/lib/neutral/chunk-H6EHIVDN.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/testing/reply.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Console from 'effect/Console';\nimport * as Effect from 'effect/Effect';\n\nimport * as Operation from '../Operation';\nimport { Reply } from './definitions';\n\nexport default Reply.pipe(\n  Operation.withHandler(\n    Effect.fn(function* (input) {\n      yield* Console.log('reply', { input });\n      return input;\n    }),\n  ),\n);\n"],
+  "mappings": ";;;;;;;;AAIA,YAAYA,aAAa;AACzB,YAAYC,YAAY;AAKxB,IAAA,gBAAeC,MAAMC,KACTC,YACDC,UAAG,WAAWC,OAAK;AACxB,SAAeC,YAAI,SAAS;IAAED;EAAM,CAAA;AACpC,SAAOA;AACT,CAAA,CAAA,CAAA;",
+  "names": ["Console", "Effect", "Reply", "pipe", "withHandler", "fn", "input", "log"]
+}

package/dist/lib/neutral/chunk-J5LGTIGS.mjs

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/lib/neutral/chunk-J5LGTIGS.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/neutral/chunk-N462A6NO.mjs

@@ -0,0 +1,138 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var InvokerNotInitializedError = class extends BaseError.extend("InvokerNotInitializedError", "Invoker not initialized") {
+  constructor() {
+    super();
+  }
+};
+var NoHandlerError = class extends BaseError.extend("NoHandlerError", "No handler found for operation. ") {
+  constructor(operationKey) {
+    super({
+      context: {
+        operationKey
+      }
+    });
+  }
+};
+var ServiceNotAvailableError = class extends BaseError.extend("ServiceNotAvailable", "Service not available") {
+  constructor(service, options) {
+    super({
+      context: {
+        service
+      },
+      ...options,
+      message: `Service not available: ${service}`
+    });
+  }
+};
+var FunctionNotFoundError = class extends BaseError.extend("FunctionNotFound", "Function not found") {
+  constructor(functionKey, options) {
+    super({
+      context: {
+        function: functionKey
+      },
+      ...options
+    });
+  }
+};
+var FunctionError = class extends BaseError.extend("FunctionError", "Function invocation error") {
+};
+var InvalidOperationInputError = class extends BaseError.extend("InvalidOperationInput", "Operation input did not match schema") {
+};
+var InvalidOperationOutputError = class extends BaseError.extend("InvalidOperationOutput", "Operation output did not match schema") {
+};
+var TriggerStateNotFoundError = class extends BaseError.extend("TriggerStateNotFound", "Trigger state not found") {
+};
+
+// src/OperationHandlerSet.ts
+var OperationHandlerSet_exports = {};
+__export(OperationHandlerSet_exports, {
+  OperationHandlerProvider: () => OperationHandlerProvider,
+  TypeId: () => TypeId,
+  async: () => async,
+  empty: () => empty,
+  getHandler: () => getHandler,
+  getHandlerByKey: () => getHandlerByKey,
+  isOperationHandlerSet: () => isOperationHandlerSet,
+  lazy: () => lazy,
+  make: () => make,
+  merge: () => merge,
+  provide: () => provide
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { assertArgument } from "@dxos/invariant";
+var TypeId = "~@dxos/operation/OperationHandlerSet";
+var isOperationHandlerSet = (value) => {
+  return typeof value === "object" && value !== null && TypeId in value;
+};
+var empty = {
+  [TypeId]: TypeId,
+  handlers: Effect.succeed([]),
+  getHandlers: () => Promise.resolve([])
+};
+var make = (...handlers) => {
+  return async(() => Promise.resolve(handlers));
+};
+var async = (getHandlers) => {
+  let promise2 = null;
+  const getHandlersCached = () => {
+    if (!promise2) {
+      promise2 = getHandlers();
+    }
+    return promise2;
+  };
+  return {
+    [TypeId]: TypeId,
+    getHandlers,
+    handlers: Effect.promise(getHandlersCached)
+  };
+};
+var merge = (...sets) => {
+  assertArgument(sets.every(isOperationHandlerSet), "sets", "sets must be an array of OperationHandlerSet");
+  return async(() => Promise.all(sets.map((set) => set.getHandlers())).then((handlers) => handlers.flat()));
+};
+var lazy = (...modules) => {
+  return async(() => Promise.all(modules.map((module) => module().then(({ default: handler }) => handler))));
+};
+var getHandler = (set, definition) => Effect.gen(function* () {
+  const handlers = yield* set.handlers;
+  const handler = handlers.find((handler2) => handler2.meta.key === definition.meta.key);
+  if (!handler) {
+    return yield* Effect.fail(new NoHandlerError(definition.meta.key));
+  }
+  return handler;
+});
+var getHandlerByKey = (set, key) => Effect.gen(function* () {
+  const handlers = yield* set.handlers;
+  const handler = handlers.find((handler2) => handler2.meta.key === key);
+  if (!handler) {
+    return yield* Effect.fail(new NoHandlerError(key));
+  }
+  return handler;
+});
+var OperationHandlerProvider = class extends Context.Tag("@dxos/operation/OperationHandlerProvider")() {
+};
+var provide = (handlers) => Layer.succeed(OperationHandlerProvider, handlers);
+
+export {
+  InvokerNotInitializedError,
+  NoHandlerError,
+  ServiceNotAvailableError,
+  FunctionNotFoundError,
+  FunctionError,
+  InvalidOperationInputError,
+  InvalidOperationOutputError,
+  TriggerStateNotFoundError,
+  lazy,
+  getHandler,
+  getHandlerByKey,
+  OperationHandlerProvider,
+  OperationHandlerSet_exports
+};
+//# sourceMappingURL=chunk-N462A6NO.mjs.map

package/dist/lib/neutral/chunk-N462A6NO.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/errors.ts", "../../../src/OperationHandlerSet.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\n\n// Errors from @dxos/operation.\n\nexport class InvokerNotInitializedError extends BaseError.extend(\n  'InvokerNotInitializedError',\n  'Invoker not initialized',\n) {\n  constructor() {\n    super();\n  }\n}\n\nexport class NoHandlerError extends BaseError.extend('NoHandlerError', 'No handler found for operation. ') {\n  constructor(operationKey: string) {\n    super({ context: { operationKey } });\n  }\n}\n\n// Errors from @dxos/functions.\n\nexport class ServiceNotAvailableError extends BaseError.extend('ServiceNotAvailable', 'Service not available') {\n  constructor(service: string, options?: Omit<BaseErrorOptions, 'context'>) {\n    super({ context: { service }, ...options, message: `Service not available: ${service}` });\n  }\n}\n\nexport class FunctionNotFoundError extends BaseError.extend('FunctionNotFound', 'Function not found') {\n  constructor(functionKey: string, options?: Omit<BaseErrorOptions, 'context'>) {\n    super({ context: { function: functionKey }, ...options });\n  }\n}\n\nexport class FunctionError extends BaseError.extend('FunctionError', 'Function invocation error') {}\n\nexport class InvalidOperationInputError extends BaseError.extend(\n  'InvalidOperationInput',\n  'Operation input did not match schema',\n) {}\n\nexport class InvalidOperationOutputError extends BaseError.extend(\n  'InvalidOperationOutput',\n  'Operation output did not match schema',\n) {}\n\nexport class TriggerStateNotFoundError extends BaseError.extend('TriggerStateNotFound', 'Trigger state not found') {}\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\n\nimport { assertArgument } from '@dxos/invariant';\n\nimport { NoHandlerError } from './errors';\nimport type * as Operation from './Operation';\n\nexport const TypeId = '~@dxos/operation/OperationHandlerSet' as const;\nexport type TypeId = typeof TypeId;\n\nexport interface OperationHandlerSet {\n  [TypeId]: TypeId;\n\n  readonly handlers: Effect.Effect<Operation.WithHandler<Operation.Definition.Any>[]>;\n\n  getHandlers(): Promise<Operation.WithHandler<Operation.Definition.Any>[]>;\n}\n\nexport const isOperationHandlerSet = (value: unknown): value is OperationHandlerSet => {\n  return typeof value === 'object' && value !== null && TypeId in value;\n};\n\nexport const empty: OperationHandlerSet = {\n  [TypeId]: TypeId,\n  handlers: Effect.succeed([]),\n  getHandlers: () => Promise.resolve([]),\n};\n\n/**\n * Creates a new operation handler set from a list of handlers.\n *\n * @example\n * ```ts\n * const set = OperationHandlerSet.make(\n *   Operation.withHandler(Operation.make({ input: Schema.Void, output: Schema.Void }), (input) => Effect.succeed({})),\n *   Operation.withHandler(Operation.make({ input: Schema.Void, output: Schema.Void }), (input) => Effect.succeed({})),\n * );\n * ```\n */\nexport const make = (...handlers: Operation.WithHandler<Operation.Definition.Any>[]): OperationHandlerSet => {\n  return async(() => Promise.resolve(handlers));\n};\n\nexport const async = (\n  getHandlers: () => Promise<Operation.WithHandler<Operation.Definition.Any>[]>,\n): OperationHandlerSet => {\n  // NOTE: Re-runing async module imports has a big performance penalty in Chrome.\n  let promise: Promise<Operation.WithHandler<Operation.Definition.Any>[]> | null = null;\n  const getHandlersCached = () => {\n    if (!promise) {\n      promise = getHandlers();\n    }\n    return promise;\n  };\n  return {\n    [TypeId]: TypeId,\n    getHandlers,\n    handlers: Effect.promise(getHandlersCached),\n  };\n};\n\n/**\n * Merges multiple operation handler sets into a single set.\n *\n */\nexport const merge = (...sets: OperationHandlerSet[]): OperationHandlerSet => {\n  assertArgument(sets.every(isOperationHandlerSet), 'sets', 'sets must be an array of OperationHandlerSet');\n  return async(() => Promise.all(sets.map((set) => set.getHandlers())).then((handlers) => handlers.flat()));\n};\n\n/**\n * Creates a new operation handler set from a list of lazy-loaded modules.\n *\n * @example\n * ```ts\n * const set = OperationHandlerSet.lazy(\n *   () => import('./my-handler'),\n *   () => import('./my-other-handler'),\n * );\n * ```\n */\nexport const lazy = (\n  ...modules: (() => Promise<{ default: Operation.WithHandler<Operation.Definition.Any> }>)[]\n): OperationHandlerSet => {\n  return async(() => Promise.all(modules.map((module) => module().then(({ default: handler }) => handler))));\n};\n\n/**\n * Gets a handler for an operation by definition.\n */\nexport const getHandler = <const Op extends Operation.Definition.Any>(\n  set: OperationHandlerSet,\n  definition: Op,\n): Effect.Effect<Operation.WithHandler<Op>, NoHandlerError> =>\n  Effect.gen(function* () {\n    const handlers = yield* set.handlers;\n    const handler = handlers.find((handler) => handler.meta.key === definition.meta.key);\n    if (!handler) {\n      return yield* Effect.fail(new NoHandlerError(definition.meta.key));\n    }\n    return handler as any;\n  });\n\n/**\n * Gets a handler for an operation by key.\n */\nexport const getHandlerByKey = (\n  set: OperationHandlerSet,\n  key: string,\n): Effect.Effect<Operation.WithHandler<Operation.Definition.Any>, NoHandlerError> =>\n  Effect.gen(function* () {\n    const handlers = yield* set.handlers;\n    const handler = handlers.find((handler) => handler.meta.key === key);\n    if (!handler) {\n      return yield* Effect.fail(new NoHandlerError(key));\n    }\n    return handler as any;\n  });\n\nexport class OperationHandlerProvider extends Context.Tag('@dxos/operation/OperationHandlerProvider')<\n  OperationHandlerProvider,\n  OperationHandlerSet\n>() {}\n\nexport const provide = (handlers: OperationHandlerSet): Layer.Layer<OperationHandlerProvider, never, never> =>\n  Layer.succeed(OperationHandlerProvider, handlers);\n"],
+  "mappings": ";;;;;AAIA,SAASA,iBAAwC;AAI1C,IAAMC,6BAAN,cAAyCD,UAAUE,OACxD,8BACA,yBAAA,EAAA;EAEA,cAAc;AACZ,UAAK;EACP;AACF;AAEO,IAAMC,iBAAN,cAA6BH,UAAUE,OAAO,kBAAkB,kCAAA,EAAA;EACrE,YAAYE,cAAsB;AAChC,UAAM;MAAEC,SAAS;QAAED;MAAa;IAAE,CAAA;EACpC;AACF;AAIO,IAAME,2BAAN,cAAuCN,UAAUE,OAAO,uBAAuB,uBAAA,EAAA;EACpF,YAAYK,SAAiBC,SAA6C;AACxE,UAAM;MAAEH,SAAS;QAAEE;MAAQ;MAAG,GAAGC;MAASC,SAAS,0BAA0BF,OAAAA;IAAU,CAAA;EACzF;AACF;AAEO,IAAMG,wBAAN,cAAoCV,UAAUE,OAAO,oBAAoB,oBAAA,EAAA;EAC9E,YAAYS,aAAqBH,SAA6C;AAC5E,UAAM;MAAEH,SAAS;QAAEO,UAAUD;MAAY;MAAG,GAAGH;IAAQ,CAAA;EACzD;AACF;AAEO,IAAMK,gBAAN,cAA4Bb,UAAUE,OAAO,iBAAiB,2BAAA,EAAA;AAA8B;AAE5F,IAAMY,6BAAN,cAAyCd,UAAUE,OACxD,yBACA,sCAAA,EAAA;AACC;AAEI,IAAMa,8BAAN,cAA0Cf,UAAUE,OACzD,0BACA,uCAAA,EAAA;AACC;AAEI,IAAMc,4BAAN,cAAwChB,UAAUE,OAAO,wBAAwB,yBAAA,EAAA;AAA4B;;;ACjDpH;;;;;;;;;;;;;;AAIA,YAAYe,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AAEvB,SAASC,sBAAsB;AAKxB,IAAMC,SAAS;AAWf,IAAMC,wBAAwB,CAACC,UAAAA;AACpC,SAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQF,UAAUE;AAClE;AAEO,IAAMC,QAA6B;EACxC,CAACH,MAAAA,GAASA;EACVI,UAAiBC,eAAQ,CAAA,CAAE;EAC3BC,aAAa,MAAMC,QAAQC,QAAQ,CAAA,CAAE;AACvC;AAaO,IAAMC,OAAO,IAAIL,aAAAA;AACtB,SAAOM,MAAM,MAAMH,QAAQC,QAAQJ,QAAAA;AACrC;AAEO,IAAMM,QAAQ,CACnBJ,gBAAAA;AAGA,MAAIK,WAA6E;AACjF,QAAMC,oBAAoB,MAAA;AACxB,QAAI,CAACD,UAAS;AACZA,MAAAA,WAAUL,YAAAA;IACZ;AACA,WAAOK;EACT;AACA,SAAO;IACL,CAACX,MAAAA,GAASA;IACVM;IACAF,UAAiBO,eAAQC,iBAAAA;EAC3B;AACF;AAMO,IAAMC,QAAQ,IAAIC,SAAAA;AACvBC,iBAAeD,KAAKE,MAAMf,qBAAAA,GAAwB,QAAQ,8CAAA;AAC1D,SAAOS,MAAM,MAAMH,QAAQU,IAAIH,KAAKI,IAAI,CAACC,QAAQA,IAAIb,YAAW,CAAA,CAAA,EAAKc,KAAK,CAAChB,aAAaA,SAASiB,KAAI,CAAA;AACvG;AAaO,IAAMC,OAAO,IACfC,YAAAA;AAEH,SAAOb,MAAM,MAAMH,QAAQU,IAAIM,QAAQL,IAAI,CAACM,WAAWA,OAAAA,EAASJ,KAAK,CAAC,EAAEK,SAASC,QAAO,MAAOA,OAAAA,CAAAA,CAAAA;AACjG;AAKO,IAAMC,aAAa,CACxBR,KACAS,eAEOC,WAAI,aAAA;AACT,QAAMzB,WAAW,OAAOe,IAAIf;AAC5B,QAAMsB,UAAUtB,SAAS0B,KAAK,CAACJ,aAAYA,SAAQK,KAAKC,QAAQJ,WAAWG,KAAKC,GAAG;AACnF,MAAI,CAACN,SAAS;AACZ,WAAO,OAAcO,YAAK,IAAIC,eAAeN,WAAWG,KAAKC,GAAG,CAAA;EAClE;AACA,SAAON;AACT,CAAA;AAKK,IAAMS,kBAAkB,CAC7BhB,KACAa,QAEOH,WAAI,aAAA;AACT,QAAMzB,WAAW,OAAOe,IAAIf;AAC5B,QAAMsB,UAAUtB,SAAS0B,KAAK,CAACJ,aAAYA,SAAQK,KAAKC,QAAQA,GAAAA;AAChE,MAAI,CAACN,SAAS;AACZ,WAAO,OAAcO,YAAK,IAAIC,eAAeF,GAAAA,CAAAA;EAC/C;AACA,SAAON;AACT,CAAA;AAEK,IAAMU,2BAAN,cAA+CC,YAAI,0CAAA,EAAA,EAAA;AAGrD;AAEE,IAAMC,UAAU,CAAClC,aAChBC,cAAQ+B,0BAA0BhC,QAAAA;",
+  "names": ["BaseError", "InvokerNotInitializedError", "extend", "NoHandlerError", "operationKey", "context", "ServiceNotAvailableError", "service", "options", "message", "FunctionNotFoundError", "functionKey", "function", "FunctionError", "InvalidOperationInputError", "InvalidOperationOutputError", "TriggerStateNotFoundError", "Context", "Effect", "Layer", "assertArgument", "TypeId", "isOperationHandlerSet", "value", "empty", "handlers", "succeed", "getHandlers", "Promise", "resolve", "make", "async", "promise", "getHandlersCached", "merge", "sets", "assertArgument", "every", "all", "map", "set", "then", "flat", "lazy", "modules", "module", "default", "handler", "getHandler", "definition", "gen", "find", "meta", "key", "fail", "NoHandlerError", "getHandlerByKey", "OperationHandlerProvider", "Tag", "provide"]
+}

package/dist/lib/neutral/chunk-QPCDM7MF.mjs

@@ -0,0 +1,179 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Operation.ts
+var Operation_exports = {};
+__export(Operation_exports, {
+  DefinitionTypeId: () => DefinitionTypeId,
+  PersistentOperation: () => PersistentOperation,
+  Service: () => Service,
+  deserialize: () => deserialize,
+  invoke: () => invoke,
+  isOperationDefinition: () => isOperationDefinition,
+  isOperationWithHandler: () => isOperationWithHandler,
+  make: () => make,
+  opaqueHandler: () => opaqueHandler,
+  schedule: () => schedule,
+  serialize: () => serialize,
+  setFrom: () => setFrom,
+  withHandler: () => withHandler,
+  withInvocationOptions: () => withInvocationOptions
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Pipeable from "effect/Pipeable";
+import * as Schema$ from "effect/Schema";
+import { Annotation, JsonSchema, Obj, Ref, Type } from "@dxos/echo";
+var DefinitionTypeId = "~@dxos/operation/OperationDefinition";
+var isOperationDefinition = (value) => {
+  return typeof value === "object" && value !== null && DefinitionTypeId in value;
+};
+var isOperationWithHandler = (value) => {
+  return isOperationDefinition(value) && "handler" in value;
+};
+var make = (props) => {
+  return {
+    [DefinitionTypeId]: {},
+    ...props,
+    executionMode: props.executionMode ?? "async",
+    types: props.types ?? [],
+    services: props.services ?? [],
+    pipe() {
+      return Pipeable.pipeArguments(this, arguments);
+    }
+  };
+};
+var withHandler = (opOrHandler, handler) => {
+  if (handler === void 0) {
+    const handlerFn = opOrHandler;
+    return (op2) => ({
+      ...op2,
+      handler: handlerFn
+    });
+  }
+  const op = opOrHandler;
+  return {
+    ...op,
+    handler
+  };
+};
+var opaqueHandler = (handler) => handler;
+var PersistentOperation = Schema$.Struct({
+  /**
+  * Global registry ID.
+  * NOTE: The `key` property refers to the original registry entry.
+  */
+  // TODO(burdon): Create Format type for DXN-like ids, such as this and schema type.
+  // TODO(dmaretskyi): Consider making it part of ECHO meta.
+  // TODO(dmaretskyi): Make required.
+  key: Schema$.optional(Schema$.String).annotations({
+    description: "Unique registration key for the blueprint"
+  }),
+  name: Schema$.NonEmptyString,
+  version: Schema$.String,
+  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.Ref(Obj.Unknown)),
+  inputSchema: Schema$.optional(JsonSchema.JsonSchema),
+  outputSchema: Schema$.optional(JsonSchema.JsonSchema),
+  /**
+  * List of required services.
+  * Match the Context.Tag keys of the FunctionServices variants.
+  */
+  services: Schema$.optional(Schema$.Array(Schema$.String)),
+  // Local binding to a function name.
+  // TODO(dmaretskyi): Add this field to Operation.Definition.
+  binding: Schema$.optional(Schema$.String)
+}).pipe(
+  // TODO(dmaretskyi): Keep typename as 'org.dxos.type.function' (not 'operation') to maintain
+  //  backward compatibility with existing data and avoid requiring data migration.
+  Type.object({
+    typename: "org.dxos.type.function",
+    version: "0.1.0"
+  }),
+  Annotation.LabelAnnotation.set([
+    "name"
+  ]),
+  Annotation.IconAnnotation.set({
+    icon: "ph--function--regular",
+    hue: "blue"
+  }),
+  Annotation.SystemTypeAnnotation.set(true)
+);
+var serialize = (operation) => {
+  return Obj.make(PersistentOperation, {
+    key: operation.meta.key,
+    name: operation.meta.name ?? "",
+    version: operation.meta.version ?? "0.0.0",
+    description: operation.meta.description,
+    updated: void 0,
+    source: void 0,
+    inputSchema: JsonSchema.toJsonSchema(operation.input),
+    outputSchema: JsonSchema.toJsonSchema(operation.output),
+    services: operation.services.map((service) => service.key)
+  });
+};
+var deserialize = (record) => {
+  const deployedId = Obj.getMeta(record).keys.find((key) => key.source === "org.dxos.service.function")?.id;
+  return make({
+    input: record.inputSchema ? JsonSchema.toEffectSchema(record.inputSchema) : Schema$.Unknown,
+    output: record.outputSchema ? JsonSchema.toEffectSchema(record.outputSchema) : Schema$.Unknown,
+    services: record.services?.map((service) => Context.GenericTag(service)) ?? [],
+    executionMode: "async",
+    types: [],
+    meta: {
+      key: record.key ?? record.name,
+      name: record.name,
+      version: record.version,
+      description: record.description,
+      deployedId
+    }
+  });
+};
+var setFrom = (target, source) => {
+  Obj.update(target, (target2) => {
+    target2.key = source.key ?? target2.key;
+    target2.name = source.name ?? target2.name;
+    target2.version = source.version;
+    target2.description = source.description;
+    target2.updated = source.updated;
+    target2.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : void 0;
+    target2.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : void 0;
+    Obj.getMeta(target2).keys = JSON.parse(JSON.stringify(Obj.getMeta(source).keys));
+  });
+};
+var Service = class extends Context.Tag("@dxos/operation/Service")() {
+};
+var invoke = (op, ...args) => Effect.flatMap(Service, (ops) => ops.invoke(op, ...args)).pipe(Effect.withSpan("Operation.invoke"));
+var schedule = (op, ...args) => Effect.flatMap(Service, (ops) => ops.schedule(op, args[0])).pipe(Effect.withSpan("Operation.schedule"));
+var withInvocationOptions = (options) => Layer.effect(Service, Effect.gen(function* () {
+  const service = yield* Service;
+  return Service.of({
+    invoke: (op, input, invocationOptions) => service.invoke(op, input, {
+      ...options,
+      ...invocationOptions
+    }),
+    invokePromise: (op, input, invocationOptions) => service.invokePromise(op, input, {
+      ...options,
+      ...invocationOptions
+    }),
+    schedule: service.schedule
+  });
+}));
+
+export {
+  make,
+  withHandler,
+  PersistentOperation,
+  deserialize,
+  invoke,
+  Operation_exports
+};
+//# sourceMappingURL=chunk-QPCDM7MF.mjs.map