@dxos/compute 0.8.4-main.dedc0f3 → 0.8.4-main.dfabb4ec29

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-XEVFBI6S.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  StorageService,
+  clear,
+  deleteKey,
+  get,
+  key,
+  list,
+  set,
+  withDefault
+};
+//# sourceMappingURL=StorageService.mjs.map

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

@@ -0,0 +1,53 @@
+import {
+  intrinsic,
+  make
+} from "./chunk-VIRNEVFD.mjs";
+
+// src/testing/definitions.ts
+import * as Schema from "effect/Schema";
+var Fibonacci = make({
+  meta: {
+    key: "org.example.function.fib",
+    name: "Fibonacci",
+    description: "Function that calculates a Fibonacci number"
+  },
+  input: Schema.Struct({
+    iterations: Schema.optional(Schema.Number).annotations({
+      description: "Number of iterations",
+      default: 1e5
+    })
+  }),
+  output: Schema.Struct({
+    result: Schema.String
+  })
+}).pipe(intrinsic);
+var Reply = make({
+  meta: {
+    key: "org.example.function.reply",
+    name: "Reply",
+    description: "Function that echoes the input"
+  },
+  input: Schema.Any,
+  output: Schema.Any
+}).pipe(intrinsic);
+var Sleep = make({
+  meta: {
+    key: "org.example.function.sleep",
+    name: "Sleep",
+    description: "Function that sleeps for a given amount of time"
+  },
+  input: Schema.Struct({
+    duration: Schema.optional(Schema.Number).annotations({
+      description: "Milliseconds to sleep",
+      default: 1e5
+    })
+  }),
+  output: Schema.Void
+}).pipe(intrinsic);
+
+export {
+  Fibonacci,
+  Reply,
+  Sleep
+};
+//# sourceMappingURL=chunk-CXDV2FPU.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/testing/definitions.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport * as Operation from '../Operation';\n\nexport const Fibonacci = Operation.make({\n  meta: {\n    key: 'org.example.function.fib',\n    name: 'Fibonacci',\n    description: 'Function that calculates a Fibonacci number',\n  },\n  input: Schema.Struct({\n    iterations: Schema.optional(Schema.Number).annotations({\n      description: 'Number of iterations',\n      default: 100_000,\n    }),\n  }),\n  output: Schema.Struct({\n    result: Schema.String,\n  }),\n}).pipe(Operation.intrinsic);\n\nexport const Reply = Operation.make({\n  meta: {\n    key: 'org.example.function.reply',\n    name: 'Reply',\n    description: 'Function that echoes the input',\n  },\n  input: Schema.Any,\n  output: Schema.Any,\n}).pipe(Operation.intrinsic);\n\nexport const Sleep = Operation.make({\n  meta: {\n    key: 'org.example.function.sleep',\n    name: 'Sleep',\n    description: 'Function that sleeps for a given amount of time',\n  },\n  input: Schema.Struct({\n    duration: Schema.optional(Schema.Number).annotations({\n      description: 'Milliseconds to sleep',\n      default: 100_000,\n    }),\n  }),\n  output: Schema.Void,\n}).pipe(Operation.intrinsic);\n"],
+  "mappings": ";;;;;;AAIA,YAAYA,YAAY;AAIjB,IAAMC,YAAsBC,KAAK;EACtCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBC,YAAmBC,gBAAgBC,aAAM,EAAEC,YAAY;MACrDN,aAAa;MACbO,SAAS;IACX,CAAA;EACF,CAAA;EACAC,QAAeN,cAAO;IACpBO,QAAeC;EACjB,CAAA;AACF,CAAA,EAAGC,KAAeC,SAAS;AAEpB,IAAMC,QAAkBjB,KAAK;EAClCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAca;EACdN,QAAeM;AACjB,CAAA,EAAGH,KAAeC,SAAS;AAEpB,IAAMG,QAAkBnB,KAAK;EAClCC,MAAM;IACJC,KAAK;IACLC,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBc,UAAiBZ,gBAAgBC,aAAM,EAAEC,YAAY;MACnDN,aAAa;MACbO,SAAS;IACX,CAAA;EACF,CAAA;EACAC,QAAeS;AACjB,CAAA,EAAGN,KAAeC,SAAS;",
+  "names": ["Schema", "Fibonacci", "make", "meta", "key", "name", "description", "input", "Struct", "iterations", "optional", "Number", "annotations", "default", "output", "result", "String", "pipe", "intrinsic", "Reply", "Any", "Sleep", "duration", "Void"]
+}

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

@@ -0,0 +1,25 @@
+import {
+  Fibonacci
+} from "./chunk-CXDV2FPU.mjs";
+import {
+  withHandler
+} from "./chunk-VIRNEVFD.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-EG7VLX2F.mjs.map

package/dist/lib/neutral/chunk-EG7VLX2F.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-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-JTZYM2QW.mjs

@@ -0,0 +1,144 @@
+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") {
+};
+var FunctionsAiUpstreamError = class extends BaseError.extend("FunctionsAiUpstreamError", "Upstream AI service returned an error") {
+};
+var FunctionsAiMemoizationMissError = class extends BaseError.extend("FunctionsAiMemoizationMissError", "No memoized AI conversation found for the given cache key") {
+};
+
+// 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,
+  FunctionsAiUpstreamError,
+  FunctionsAiMemoizationMissError,
+  lazy,
+  getHandler,
+  getHandlerByKey,
+  OperationHandlerProvider,
+  OperationHandlerSet_exports
+};
+//# sourceMappingURL=chunk-JTZYM2QW.mjs.map

package/dist/lib/neutral/chunk-JTZYM2QW.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/**\n * Raised when the upstream AI gateway responds with a structured JSON error envelope\n * (`{ \"type\": \"error\", \"error\": { \"type\": ..., \"message\": ... } }`). Surfaces as a typed\n * defect from `FunctionsAiHttpClient`, bypassing `@effect/ai`'s generic `HttpResponseError`\n * wrapping so callers can match on the error class directly.\n */\nexport class FunctionsAiUpstreamError extends BaseError.extend(\n  'FunctionsAiUpstreamError',\n  'Upstream AI service returned an error',\n) {}\n\n/**\n * Specialized `FunctionsAiUpstreamError` for the memoization layer: the recorded fixture for a\n * given cache key was not found and `ALLOW_LLM_GENERATION` is unset. The `cacheKey` is exposed\n * via `context.cacheKey` to make regeneration straightforward.\n */\nexport class FunctionsAiMemoizationMissError extends BaseError.extend(\n  'FunctionsAiMemoizationMissError',\n  'No memoized AI conversation found for the given cache key',\n) {}\n", "//\n// Copyright 2026 DXOS.org\n//\n\n// @import-as-namespace\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": "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",
+  "names": ["BaseError", "InvokerNotInitializedError", "extend", "NoHandlerError", "operationKey", "context", "ServiceNotAvailableError", "service", "options", "message", "FunctionNotFoundError", "functionKey", "function", "FunctionError", "InvalidOperationInputError", "InvalidOperationOutputError", "TriggerStateNotFoundError", "FunctionsAiUpstreamError", "FunctionsAiMemoizationMissError", "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-OA7JMLJK.mjs

@@ -0,0 +1,17 @@
+import {
+  Sleep
+} from "./chunk-CXDV2FPU.mjs";
+import {
+  withHandler
+} from "./chunk-VIRNEVFD.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-OA7JMLJK.mjs.map

package/dist/lib/neutral/chunk-OA7JMLJK.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-VIRNEVFD.mjs

@@ -0,0 +1,199 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Operation.ts
+var Operation_exports = {};
+__export(Operation_exports, {
+  DefinitionTypeId: () => DefinitionTypeId,
+  PersistentOperation: () => PersistentOperation,
+  Service: () => Service,
+  deserialize: () => deserialize,
+  intrinsic: () => intrinsic,
+  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 intrinsic = (op) => {
+  return {
+    ...op,
+    meta: {
+      ...op.meta,
+      deployedId: `intrinsic:${op.meta.key}`
+    }
+  };
+};
+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 FUNCTION_META_KEY = "org.dxos.service.function";
+var serialize = (operation) => {
+  return Obj.make(PersistentOperation, {
+    [Obj.Meta]: {
+      keys: operation.meta.deployedId ? [
+        {
+          source: FUNCTION_META_KEY,
+          id: operation.meta.deployedId
+        }
+      ] : []
+    },
+    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 === FUNCTION_META_KEY)?.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,
+  intrinsic,
+  withHandler,
+  PersistentOperation,
+  deserialize,
+  invoke,
+  Operation_exports
+};
+//# sourceMappingURL=chunk-VIRNEVFD.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Operation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema$ from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { Annotation, JsonSchema, Obj, Ref, Type, type DXN, type Key } from '@dxos/echo';\n\nimport type { NoHandlerError } from './errors';\nimport type { Operation } from './index';\n\n/**\n * Schema type that accepts any Encoded form but requires no Context.\n * This allows ECHO object schemas where Type !== Encoded due to [KindId] symbol.\n */\ntype Schema<T> = Schema$.Schema<T, any, never>;\n\nexport const DefinitionTypeId = '~@dxos/operation/OperationDefinition' as const;\nexport type DefinitionTypeId = typeof DefinitionTypeId;\n\n/**\n * Serializable definition of an Operation.\n * Contains schema and metadata, but no runtime logic.\n */\nexport interface Definition<I, O, S = any> extends Pipeable.Pipeable, Definition.Variance<I, O, S> {\n  /**\n   * Input schema for the operation.\n   */\n  readonly input: Schema<I>;\n  /**\n   * Output schema for the operation.\n   */\n  readonly output: Schema<O>;\n\n  readonly meta: {\n    readonly key: string;\n    readonly name?: string;\n    readonly version?: string;\n    readonly description?: string;\n    /**\n     * Deployment ID for remote invocation.\n     * Assigned by the EDGE function service when deployed.\n     */\n    readonly deployedId?: string;\n  };\n\n  /**\n   * Execution mode for the operation.\n   * - 'sync': Operation completes synchronously (fast, UI-blocking acceptable).\n   * - 'async': Operation may take time (should not block UI).\n   */\n  readonly executionMode: 'sync' | 'async';\n\n  /**\n   * ECHO types the operation uses.\n   * Ensures types are available when the operation is executed remotely.\n   */\n  readonly types: readonly Type.AnyEntity[];\n\n  /**\n   * Effect services required by this operation.\n   * These services will be automatically provided to the handler at invocation time.\n   */\n  readonly services: readonly Context.Tag<any, any>[];\n}\n\n/**\n * Namespace for OperationDefinition helper types.\n */\nexport declare namespace Definition {\n  export interface Variance<I, O, S> {\n    [DefinitionTypeId]: {\n      readonly _Input: Types.Contravariant<I>;\n      readonly _Output: Types.Covariant<O>;\n      readonly _Services: Types.Covariant<S>;\n    };\n  }\n\n  /**\n   * Any operation definition, regardless of input/output types.\n   */\n  export type Any = Definition<any, any, any>;\n\n  /**\n   * Extract the input type from an operation definition.\n   */\n  export type Input<T extends Any> = T extends Variance<infer I, infer _O, infer _S> ? I : never;\n\n  /**\n   * Extract the output type from an operation definition.\n   */\n  export type Output<T extends Any> = T extends Variance<infer _I, infer O, infer _S> ? O : never;\n\n  /**\n   * Extract the service identifier types from an operation's services array.\n   * Returns `never` if the operation has no services declared.\n   */\n  export type Services<T extends Any> = T extends Variance<infer _I, infer _O, infer S> ? S : never;\n\n  export type HandlerType<T extends Any> =\n    T extends Variance<infer I, infer O, infer S> ? Handler<I, O, any, S> : never;\n}\n\n/**\n * Runtime handler for an Operation.\n */\nexport type Handler<I, O, E = Error, R = never> = (input: I) => Effect.Effect<O, E, R>;\n\nexport type WithHandler<T extends Definition.Any> = T & {\n  handler: Definition.HandlerType<T>;\n};\n\n/**\n * Checks if a value is an operation definition.\n */\nexport const isOperationDefinition = (value: unknown): value is Definition.Any => {\n  return typeof value === 'object' && value !== null && DefinitionTypeId in value;\n};\n\n/**\n * Checks if a value is an operation with a handler.\n */\nexport const isOperationWithHandler = (value: unknown): value is WithHandler<Definition.Any> => {\n  return isOperationDefinition(value) && 'handler' in value;\n};\n\n/**a\n * Props for creating an Operation definition.\n * Derived from OperationDefinition with executionMode made optional (defaults to 'async').\n */\nexport type Props<I, O> = Omit<Definition<I, O>, DefinitionTypeId | 'pipe' | 'executionMode' | 'types' | 'services'> & {\n  readonly executionMode?: 'sync' | 'async';\n  readonly types?: Definition<I, O>['types'];\n  readonly services?: Definition<I, O>['services'];\n};\n\n/**\n * Creates a new Operation definition.\n * Applies default executionMode of 'async' if not specified.\n * The returned type preserves the literal types of props (including services).\n */\nexport const make = <const P extends Types.NoExcessProperties<Props<any, any>, P>>(\n  props: P,\n): Definition<\n  Schema$.Schema.Type<P['input']>,\n  Schema$.Schema.Type<P['output']>,\n  Context.Tag.Identifier<NonNullable<P['services']>[number]>\n> => {\n  return {\n    [DefinitionTypeId]: {},\n    ...props,\n    executionMode: props.executionMode ?? 'async',\n    types: props.types ?? [],\n    services: props.services ?? [],\n    pipe() {\n      // eslint-disable-next-line prefer-rest-params\n      return Pipeable.pipeArguments(this, arguments);\n    },\n  } as any;\n};\n\n/**\n * Marks an operation as intrinsic — provided directly by the DXOS platform runtime rather than\n * deployed as a user function. The `intrinsic:<key>` deployedId routes invocations to the\n * built-in implementation registered with the runtime.\n */\nexport const intrinsic = <const O extends Operation.Definition.Any>(op: O): O => {\n  return {\n    ...op,\n    meta: {\n      ...op.meta,\n      deployedId: `intrinsic:${op.meta.key}`,\n    },\n  };\n};\n\n/**\n * Attaches a handler to an Operation definition.\n * The handler may use any services declared in the operation, plus Operation.Service (always available).\n * Dual API: can be called directly or used in a pipe.\n *\n * @example\n * ```ts\n * const MyOp = Operation.make({\n *   input: Schema.Void,\n *   output: Schema.Void,\n *   meta: { key: 'my-op' },\n *   services: [DatabaseService],\n * });\n *\n * // Direct call - handler can use DatabaseService\n * const op = Operation.withHandler(MyOp, (input) =>\n *   Effect.gen(function* () {\n *     const db = yield* DatabaseService;\n *     return {};\n *   }),\n * );\n *\n * // Piped call\n * const op = MyOp.pipe(Operation.withHandler((input) => Effect.succeed({})));\n * ```\n */\nexport const withHandler: {\n  <Def extends Definition<any, any>, E = never>(\n    handler: Handler<Definition.Input<Def>, Definition.Output<Def>, E, Definition.Services<Def> | Service>,\n  ): (op: Def) => WithHandler<Def>;\n  <Def extends Definition<any, any>, E = never>(\n    op: Def,\n    handler: Handler<Definition.Input<Def>, Definition.Output<Def>, E, Definition.Services<Def> | Service>,\n  ): WithHandler<Def>;\n} = <Def extends Definition<any, any>, E = never>(\n  opOrHandler: Def | Handler<Definition.Input<Def>, Definition.Output<Def>, E, Definition.Services<Def> | Service>,\n  handler?: Handler<Definition.Input<Def>, Definition.Output<Def>, E, Definition.Services<Def> | Service>,\n): WithHandler<Def> => {\n  // If called with just handler (piped usage).\n  if (handler === undefined) {\n    const handlerFn = opOrHandler as Handler<\n      Definition.Input<Def>,\n      Definition.Output<Def>,\n      E,\n      Definition.Services<Def> | Service\n    >;\n    return ((op: Def) => ({\n      ...op,\n      handler: handlerFn,\n    })) as any;\n  }\n\n  // If called with both op and handler (direct usage).\n  const op = opOrHandler as Def;\n  return {\n    ...op,\n    handler,\n  } as any;\n};\n\n/**\n * Helper to make the handler type opaque.\n * Workaround for TypeScript's inability to infer the handler type from the operation definition:\n * ```\n * error TS2742: The inferred type of 'default' cannot be named without a reference.\n * ```\n *\n * Most of the time the exact handler type is not needed.\n *\n * @example\n * ```ts\n * const MyOp = Operation.make({\n *   input: Schema.Void,\n *   output: Schema.Void,\n *   meta: { key: 'my-op' },\n *   services: [DatabaseService],\n * });\n *\n * export default MyOp.pipe(\n *   Operation.withHandler(\n *     Effect.fn(function* (input) {\n *       return { result: 'ok' };\n *     }),\n *   ),\n *   Operation.opaqueHandler,\n * );\n * ```\n */\nexport const opaqueHandler = <T extends Operation.Definition.Any>(\n  handler: Operation.WithHandler<T>,\n): Operation.WithHandler<Operation.Definition.Any> => handler;\n\n//\n// Invocation Interfaces\n//\n\n/**\n * Local invocation of an operation.\n */\nexport type Invoke = <I, O, E>(op: Definition<I, O>, input: I) => Effect.Effect<O, E>;\n\n/**\n * Remote invocation of an operation.\n */\nexport type InvokeRemote = <I, O, E>(\n  op: Definition<I, O>,\n  input: I,\n  options?: { timeout?: number },\n) => Effect.Effect<O, E>;\n\n/**\n * Database record of an operation.\n */\nexport const PersistentOperation = Schema$.Struct({\n  /**\n   * Global registry ID.\n   * NOTE: The `key` property refers to the original registry entry.\n   */\n  // TODO(burdon): Create Format type for DXN-like ids, such as this and schema type.\n  // TODO(dmaretskyi): Consider making it part of ECHO meta.\n  // TODO(dmaretskyi): Make required.\n  key: Schema$.optional(Schema$.String).annotations({\n    description: 'Unique registration key for the blueprint',\n  }),\n\n  name: Schema$.NonEmptyString,\n  version: Schema$.String,\n\n  description: Schema$.optional(Schema$.String),\n\n  /**\n   * ISO date string of the last deployment.\n   */\n  updated: Schema$.optional(Schema$.String),\n\n  // Reference to a source script if it exists within ECHO.\n  // TODO(burdon): Don't ref ScriptType directly (core).\n  source: Schema$.optional(Ref.Ref(Obj.Unknown)),\n\n  inputSchema: Schema$.optional(JsonSchema.JsonSchema),\n  outputSchema: Schema$.optional(JsonSchema.JsonSchema),\n\n  /**\n   * List of required services.\n   * Match the Context.Tag keys of the FunctionServices variants.\n   */\n  services: Schema$.optional(Schema$.Array(Schema$.String)),\n\n  // Local binding to a function name.\n  // TODO(dmaretskyi): Add this field to Operation.Definition.\n  binding: Schema$.optional(Schema$.String),\n}).pipe(\n  // TODO(dmaretskyi): Keep typename as 'org.dxos.type.function' (not 'operation') to maintain\n  //  backward compatibility with existing data and avoid requiring data migration.\n  Type.object({\n    typename: 'org.dxos.type.function',\n    version: '0.1.0',\n  }),\n  Annotation.LabelAnnotation.set(['name']),\n  Annotation.IconAnnotation.set({ icon: 'ph--function--regular', hue: 'blue' }),\n  Annotation.SystemTypeAnnotation.set(true),\n);\nexport interface PersistentOperation extends Schema$.Schema.Type<typeof PersistentOperation> {}\n\nconst FUNCTION_META_KEY = 'org.dxos.service.function';\n\n/**\n * Serialize an operation definition to a persistent operation record.\n */\nexport const serialize = (operation: Definition.Any): PersistentOperation => {\n  return Obj.make(PersistentOperation, {\n    [Obj.Meta]: {\n      keys: operation.meta.deployedId ? [{ source: FUNCTION_META_KEY, id: operation.meta.deployedId }] : [],\n    },\n    key: operation.meta.key,\n    name: operation.meta.name ?? '',\n    version: operation.meta.version ?? '0.0.0',\n    description: operation.meta.description,\n    updated: undefined,\n    source: undefined,\n    inputSchema: JsonSchema.toJsonSchema(operation.input),\n    outputSchema: JsonSchema.toJsonSchema(operation.output),\n    services: operation.services.map((service) => service.key),\n  });\n};\n\n/**\n * Deserialize a persistent operation record to an operation definition.\n */\nexport const deserialize = (record: PersistentOperation): Definition.Any => {\n  // Extract deployed function ID from ECHO meta keys (matches FUNCTIONS_META_KEY in @dxos/functions).\n  const deployedId = Obj.getMeta(record).keys.find((key) => key.source === FUNCTION_META_KEY)?.id;\n  return make({\n    input: record.inputSchema ? JsonSchema.toEffectSchema(record.inputSchema) : Schema$.Unknown,\n    output: record.outputSchema ? JsonSchema.toEffectSchema(record.outputSchema) : Schema$.Unknown,\n    services: record.services?.map((service) => Context.GenericTag(service)) ?? [],\n    executionMode: 'async',\n    types: [],\n    meta: {\n      key: record.key ?? record.name,\n      name: record.name,\n      version: record.version,\n      description: record.description,\n      deployedId,\n    },\n  });\n};\n\n/**\n * Update properties on the target operation record from the source operation record.\n */\nexport const setFrom = (target: PersistentOperation, source: PersistentOperation) => {\n  Obj.update(target, (target) => {\n    target.key = source.key ?? target.key;\n    target.name = source.name ?? target.name;\n    target.version = source.version;\n    target.description = source.description;\n    target.updated = source.updated;\n    // TODO(dmaretskyi): A workaround for an ECHO bug.\n    target.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : undefined;\n    target.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : undefined;\n    Obj.getMeta(target).keys = JSON.parse(JSON.stringify(Obj.getMeta(source).keys));\n  });\n};\n\n/**\n * Options for operation invocation.\n */\nexport interface InvokeOptions {\n  /**\n   * Space ID to provide database context for the handler.\n   */\n  spaceId?: Key.SpaceId;\n  /**\n   * DXN string of the conversation feed (queue).\n   * Passed to the process environment so nested operations can resolve AiContextService and related services.\n   */\n  conversation?: DXN.String;\n  /**\n   * Optional process-runtime tracing metadata (consumed by `@dxos/functions-runtime` when wired).\n   */\n  tracing?: unknown;\n}\n\n/**\n * Operation service interface - provides unified access to operation invocation and scheduling.\n * This service is automatically provided to operation handlers.\n */\nexport interface OperationService {\n  /**\n   * Invoke an operation as an Effect.\n   * Returns an Effect that resolves to the operation output.\n   */\n  invoke: <I, O>(\n    op: Operation.Definition<I, O>,\n    ...args: void extends I ? [input?: I, options?: InvokeOptions] : [input: I, options?: InvokeOptions]\n  ) => Effect.Effect<O, NoHandlerError>;\n\n  /**\n   * Schedule an operation to run as a followup.\n   * The followup is tracked and won't be cancelled when the parent operation completes.\n   * Returns an Effect that completes immediately after scheduling.\n   */\n  schedule: <I, O>(\n    op: Operation.Definition<I, O>,\n    ...args: void extends I ? [input?: I] : [input: I]\n  ) => Effect.Effect<void>;\n\n  /**\n   * Invoke an operation and return a Promise.\n   * Useful for async contexts where Effect is not available.\n   */\n  invokePromise: <I, O>(\n    op: Operation.Definition<I, O>,\n    ...args: void extends I ? [input?: I, options?: InvokeOptions] : [input: I, options?: InvokeOptions]\n  ) => Promise<{ data?: O; error?: Error }>;\n}\n\n/**\n * Context tag for the Operation service.\n * Operation handlers can yield this to invoke other operations or schedule followups.\n *\n * @example\n * ```ts\n * const handler = (input) => Effect.gen(function* () {\n *   // Schedule a followup (fire and forget)\n *   yield* Operation.schedule(AnalyticsOperation, { event: 'completed' });\n *\n *   // Invoke another operation\n *   return yield* Operation.invoke(OtherOperation, { data: input.data });\n * });\n * ```\n */\n// TODO(dmaretskyi): Rename Operation.Invoker\nexport class Service extends Context.Tag('@dxos/operation/Service')<Service, OperationService>() {}\n\n//\n// Namespace functions - ergonomic access to Operation.Service methods.\n//\n\n/**\n * Invoke an operation as an Effect.\n * Yields the Operation.Service internally.\n *\n * @example\n * ```ts\n * yield* Operation.invoke(MyOperation, { data: 'test' });\n * ```\n */\nexport const invoke = <I, O>(\n  op: Operation.Definition<I, O>,\n  ...args: void extends I ? [input?: I, options?: InvokeOptions] : [input: I, options?: InvokeOptions]\n): Effect.Effect<O, NoHandlerError, Service> =>\n  Effect.flatMap(Service, (ops) => ops.invoke(op, ...(args as [I, InvokeOptions?]))).pipe(\n    Effect.withSpan('Operation.invoke'),\n  );\n\n/**\n * Schedule an operation to run as a followup.\n * Yields the Operation.Service internally.\n *\n * @example\n * ```ts\n * yield* Operation.schedule(AnalyticsOperation, { event: 'completed' });\n * yield* Operation.schedule(VoidOperation); // input optional when void\n * ```\n */\nexport const schedule = <I, O>(\n  op: Operation.Definition<I, O>,\n  ...args: void extends I ? [input?: I] : [input: I]\n): Effect.Effect<void, never, Service> =>\n  Effect.flatMap(Service, (ops) => ops.schedule(op, args[0] as I)).pipe(Effect.withSpan('Operation.schedule'));\n\n/**\n * Provides additional invocation options to all invocations.\n */\nexport const withInvocationOptions = (options: InvokeOptions): Layer.Layer<Service, never, Service> =>\n  Layer.effect(\n    Service,\n    Effect.gen(function* () {\n      const service = yield* Service;\n      return Service.of({\n        invoke: ((op: Operation.Definition.Any, input: any, invocationOptions: InvokeOptions) =>\n          service.invoke(op, input, { ...options, ...invocationOptions })) as any,\n        invokePromise: ((op: Operation.Definition.Any, input: any, invocationOptions: InvokeOptions) =>\n          service.invokePromise(op, input, { ...options, ...invocationOptions })) as any,\n        schedule: service.schedule,\n      });\n    }),\n  );\n"],
+  "mappings": "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",
+  "names": ["Context", "Effect", "Layer", "Pipeable", "Schema$", "Annotation", "JsonSchema", "Obj", "Ref", "Type", "DefinitionTypeId", "isOperationDefinition", "value", "isOperationWithHandler", "make", "props", "executionMode", "types", "services", "pipe", "pipeArguments", "arguments", "intrinsic", "op", "meta", "deployedId", "key", "withHandler", "opOrHandler", "handler", "undefined", "handlerFn", "opaqueHandler", "PersistentOperation", "Struct", "optional", "String", "annotations", "description", "name", "NonEmptyString", "version", "updated", "source", "Unknown", "inputSchema", "outputSchema", "Array", "binding", "object", "typename", "LabelAnnotation", "set", "IconAnnotation", "icon", "hue", "SystemTypeAnnotation", "FUNCTION_META_KEY", "serialize", "operation", "Meta", "keys", "id", "toJsonSchema", "input", "output", "map", "service", "deserialize", "record", "getMeta", "find", "toEffectSchema", "GenericTag", "setFrom", "target", "update", "JSON", "parse", "stringify", "Service", "Tag", "invoke", "args", "flatMap", "ops", "withSpan", "schedule", "withInvocationOptions", "options", "effect", "gen", "of", "invocationOptions", "invokePromise"]
+}