@dxos/compute 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/dist/lib/neutral/{chunk-RCLYF66G.mjs → chunk-7ETNWNHW.mjs}

@@ -1,9 +1,9 @@
 import {
   Reply
-} from "./chunk-VSICPGGY.mjs";
+} from "./chunk-DC4S2HKY.mjs";
 import {
   withHandler
-} from "./chunk-SEBWOTOU.mjs";
+} from "./chunk-OKWXDYEB.mjs";
 
 // src/testing/reply.ts
 import * as Console from "effect/Console";
@@ -18,4 +18,4 @@ var reply_default = Reply.pipe(withHandler(Effect.fn(function* (input) {
 export {
   reply_default
 };
-//# sourceMappingURL=chunk-RCLYF66G.mjs.map
+//# sourceMappingURL=chunk-7ETNWNHW.mjs.map

package/dist/lib/neutral/{chunk-LF2ANNYW.mjs → chunk-CHYJAS4L.mjs}

@@ -24,8 +24,8 @@ var ServiceNotAvailableError = class extends BaseError.extend("ServiceNotAvailab
       context: {
         service
       },
-      ...options,
-      message: `Service not available: ${service}`
+      message: `Service not available: ${service}`,
+      ...options
     });
   }
 };
@@ -74,6 +74,7 @@ import { pipe } from "effect/Function";
 import * as Layer from "effect/Layer";
 import { runAndForwardErrors } from "@dxos/effect";
 import { assertArgument } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
 var TypeId = "~@dxos/operation/OperationHandlerSet";
 var isOperationHandlerSet = (value) => {
   return typeof value === "object" && value !== null && TypeId in value;
@@ -141,7 +142,9 @@ var getHandler = (set, definition) => Effect.gen(function* () {
 });
 var getHandlerByKey = (set, key) => Effect.gen(function* () {
   const handlers = yield* set.handlers;
-  const handler = handlers.find((handler2) => handler2.meta.key === key);
+  const normalizeKey = (k) => DXN.isDXN(k) ? DXN.getName(k) : k;
+  const normalizedKey = normalizeKey(key);
+  const handler = handlers.find((handler2) => normalizeKey(handler2.meta.key) === normalizedKey);
   if (!handler) {
     return yield* Effect.fail(new NoHandlerError(key));
   }
@@ -168,4 +171,4 @@ export {
   OperationHandlerProvider,
   OperationHandlerSet_exports
 };
-//# sourceMappingURL=chunk-LF2ANNYW.mjs.map
+//# sourceMappingURL=chunk-CHYJAS4L.mjs.map

package/dist/lib/neutral/chunk-CHYJAS4L.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 }, message: `Service not available: ${service}`, ...options });\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 { type Atom, type Registry } from '@effect-atom/atom';\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport { pipe } from 'effect/Function';\nimport * as Layer from 'effect/Layer';\n\nimport { runAndForwardErrors } from '@dxos/effect';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\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 * Builds a set backed by an atom of contributed sets. The merged result is\n * cached and invalidated whenever the atom changes, so most accesses are\n * cheap but newly registered handlers are picked up.\n */\nexport const reactive = (\n  registry: Registry.Registry,\n  atom: Atom.Atom<readonly OperationHandlerSet[]>,\n): OperationHandlerSet => {\n  let cached: Promise<Operation.WithHandler<Operation.Definition.Any>[]> | null = null;\n  registry.subscribe(atom, () => {\n    cached = null;\n  });\n  // `suspend` defers `registry.get(atom)` until each run, so re-evaluations\n  // after cache invalidation see the current contributed sets.\n  const compute = Effect.suspend(() =>\n    pipe(\n      registry.get(atom),\n      Effect.forEach((set) => set.handlers, { concurrency: 'unbounded' }),\n      Effect.map((groups) => groups.flat()),\n      // Reset cached on failure so a transient error doesn't permanently\n      // poison subsequent calls.\n      Effect.tapErrorCause(() =>\n        Effect.sync(() => {\n          cached = null;\n        }),\n      ),\n    ),\n  );\n  const getHandlers = () => (cached ??= runAndForwardErrors(compute));\n  return {\n    [TypeId]: TypeId,\n    getHandlers,\n    handlers: Effect.promise(getHandlers),\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 * Accepts either a plain NSID (`org.dxos.function.database.contextAdd`) or a\n * full DXN string (`dxn:org.dxos.function.database.contextAdd`).\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    // Normalize both sides to plain NSID for comparison so callers can pass\n    // either a ToolId (plain NSID) or a full DXN string.\n    const normalizeKey = (k: string) => (DXN.isDXN(k) ? DXN.getName(k) : k);\n    const normalizedKey = normalizeKey(key);\n    const handler = handlers.find((handler) => normalizeKey(handler.meta.key) === normalizedKey);\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", "pipe", "Layer", "runAndForwardErrors", "assertArgument", "DXN", "TypeId", "isOperationHandlerSet", "value", "empty", "handlers", "succeed", "getHandlers", "Promise", "resolve", "make", "async", "promise", "getHandlersCached", "reactive", "registry", "atom", "cached", "subscribe", "compute", "suspend", "pipe", "get", "forEach", "set", "concurrency", "map", "groups", "flat", "tapErrorCause", "sync", "runAndForwardErrors", "merge", "sets", "assertArgument", "every", "all", "then", "lazy", "modules", "module", "default", "handler", "getHandler", "definition", "gen", "find", "meta", "key", "fail", "NoHandlerError", "getHandlerByKey", "normalizeKey", "k", "DXN", "isDXN", "getName", "normalizedKey", "OperationHandlerProvider", "Tag", "provide"]
+}

package/dist/lib/neutral/{chunk-VSICPGGY.mjs → chunk-DC4S2HKY.mjs}

@@ -1,13 +1,13 @@
 import {
-  intrinsic,
   make
-} from "./chunk-SEBWOTOU.mjs";
+} from "./chunk-OKWXDYEB.mjs";
 
 // src/testing/definitions.ts
 import * as Schema from "effect/Schema";
+import { DXN } from "@dxos/keys";
 var Fibonacci = make({
   meta: {
-    key: "org.example.function.fib",
+    key: DXN.make("org.example.function.fib"),
     name: "Fibonacci",
     description: "Function that calculates a Fibonacci number"
   },
@@ -20,19 +20,19 @@ var Fibonacci = make({
   output: Schema.Struct({
     result: Schema.String
   })
-}).pipe(intrinsic);
+});
 var Reply = make({
   meta: {
-    key: "org.example.function.reply",
+    key: DXN.make("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",
+    key: DXN.make("org.example.function.sleep"),
     name: "Sleep",
     description: "Function that sleeps for a given amount of time"
   },
@@ -43,11 +43,11 @@ var Sleep = make({
     })
   }),
   output: Schema.Void
-}).pipe(intrinsic);
+});
 
 export {
   Fibonacci,
   Reply,
   Sleep
 };
-//# sourceMappingURL=chunk-VSICPGGY.mjs.map
+//# sourceMappingURL=chunk-DC4S2HKY.mjs.map

package/dist/lib/neutral/chunk-DC4S2HKY.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 { DXN } from '@dxos/keys';\n\nimport * as Operation from '../Operation';\n\nexport const Fibonacci = Operation.make({\n  meta: {\n    key: DXN.make('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});\n\nexport const Reply = Operation.make({\n  meta: {\n    key: DXN.make('org.example.function.reply'),\n    name: 'Reply',\n    description: 'Function that echoes the input',\n  },\n  input: Schema.Any,\n  output: Schema.Any,\n});\n\nexport const Sleep = Operation.make({\n  meta: {\n    key: DXN.make('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});\n"],
+  "mappings": ";;;;;AAIA,YAAYA,YAAY;AAExB,SAASC,WAAW;AAIb,IAAMC,YAAsBC,KAAK;EACtCC,MAAM;IACJC,KAAKC,IAAIH,KAAK,0BAAA;IACdI,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;AAEO,IAAMC,QAAkBhB,KAAK;EAClCC,MAAM;IACJC,KAAKC,IAAIH,KAAK,4BAAA;IACdI,MAAM;IACNC,aAAa;EACf;EACAC,OAAcW;EACdJ,QAAeI;AACjB,CAAA;AAEO,IAAMC,QAAkBlB,KAAK;EAClCC,MAAM;IACJC,KAAKC,IAAIH,KAAK,4BAAA;IACdI,MAAM;IACNC,aAAa;EACf;EACAC,OAAcC,cAAO;IACnBY,UAAiBV,gBAAgBC,aAAM,EAAEC,YAAY;MACnDN,aAAa;MACbO,SAAS;IACX,CAAA;EACF,CAAA;EACAC,QAAeO;AACjB,CAAA;",
+  "names": ["Schema", "DXN", "Fibonacci", "make", "meta", "key", "DXN", "name", "description", "input", "Struct", "iterations", "optional", "Number", "annotations", "default", "output", "result", "String", "Reply", "Any", "Sleep", "duration", "Void"]
+}

package/dist/lib/neutral/{chunk-AKVCVI6N.mjs → chunk-HXPMSLL7.mjs}

@@ -1,9 +1,9 @@
 import {
   Fibonacci
-} from "./chunk-VSICPGGY.mjs";
+} from "./chunk-DC4S2HKY.mjs";
 import {
   withHandler
-} from "./chunk-SEBWOTOU.mjs";
+} from "./chunk-OKWXDYEB.mjs";
 
 // src/testing/fib.ts
 import * as Effect from "effect/Effect";
@@ -22,4 +22,4 @@ var fib_default = Fibonacci.pipe(withHandler(Effect.fn(function* ({ iterations =
 export {
   fib_default
 };
-//# sourceMappingURL=chunk-AKVCVI6N.mjs.map
+//# sourceMappingURL=chunk-HXPMSLL7.mjs.map

package/dist/lib/neutral/{chunk-SEBWOTOU.mjs → chunk-OKWXDYEB.mjs}

@@ -12,7 +12,6 @@ __export(Operation_exports, {
   deserialize: () => deserialize,
   getKey: () => getKey,
   getVersion: () => getVersion,
-  intrinsic: () => intrinsic,
   invoke: () => invoke,
   isOperationDefinition: () => isOperationDefinition,
   isOperationWithHandler: () => isOperationWithHandler,
@@ -30,7 +29,7 @@ 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, Migration, Obj, Ref, Type } from "@dxos/echo";
+import { DXN, Annotation, JsonSchema, Migration, Obj, Ref, Type } from "@dxos/echo";
 var DefinitionTypeId = "~@dxos/operation/OperationDefinition";
 var isOperationDefinition = (value) => {
   return typeof value === "object" && value !== null && DefinitionTypeId in value;
@@ -50,15 +49,6 @@ var make = (props) => {
     }
   };
 };
-var intrinsic = (op) => {
-  return {
-    ...op,
-    meta: {
-      ...op.meta,
-      deployedId: `intrinsic:${op.meta.key}`
-    }
-  };
-};
 var withHandler = (opOrHandler, handler) => {
   if (handler === void 0) {
     const handlerFn = opOrHandler;
@@ -93,14 +83,12 @@ var PersistentOperation = Schema$.Struct({
   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)
+  binding: Schema$.optional(Schema$.String),
+  /**
+  * Phosphor icon identifier in `ph--<name>--<variant>` format (e.g. `ph--file-text--regular`).
+  */
+  icon: 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.2.0"
-  }),
   Annotation.LabelAnnotation.set([
     "name"
   ]),
@@ -108,7 +96,10 @@ var PersistentOperation = Schema$.Struct({
     icon: "ph--function--regular",
     hue: "blue"
   }),
-  Annotation.SystemTypeAnnotation.set(true)
+  Annotation.HiddenAnnotation.set(true),
+  // TODO(dmaretskyi): Keep typename as 'org.dxos.type.function' (not 'operation') to maintain
+  //  backward compatibility with existing data and avoid requiring data migration.
+  Type.makeObject(DXN.make("org.dxos.type.function", "0.2.0"))
 );
 var FUNCTION_META_KEY = "org.dxos.service.function";
 var getKey = (record) => Obj.getMeta(record).key;
@@ -123,10 +114,12 @@ var serialize = (operation) => {
           source: FUNCTION_META_KEY,
           id: operation.meta.deployedId
         }
-      ] : []
+      ] : [],
+      annotations: operation.meta.annotations
     },
     name: operation.meta.name ?? "",
     description: operation.meta.description,
+    icon: operation.meta.icon,
     updated: void 0,
     source: void 0,
     inputSchema: JsonSchema.toJsonSchema(operation.input),
@@ -144,11 +137,13 @@ var deserialize = (record) => {
     executionMode: "async",
     types: [],
     meta: {
-      key: meta.key ?? record.name,
+      key: DXN.tryMake(meta.key ?? record.name) ?? DXN.make(meta.key ?? record.name),
       name: record.name,
       version: meta.version ?? "0.0.0",
       description: record.description,
-      deployedId
+      icon: record.icon,
+      deployedId,
+      annotations: meta.annotations ?? {}
     }
   });
 };
@@ -156,6 +151,7 @@ var setFrom = (target, source) => {
   Obj.update(target, (target2) => {
     target2.name = source.name ?? target2.name;
     target2.description = source.description;
+    target2.icon = source.icon;
     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;
@@ -166,12 +162,13 @@ var setFrom = (target, source) => {
     if (sourceMeta.keys.length > 0) {
       targetMeta.keys = JSON.parse(JSON.stringify(sourceMeta.keys));
     }
+    targetMeta.annotations = sourceMeta.annotations ?? targetMeta.annotations;
   });
 };
 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 schedule = (op, ...args) => Effect.flatMap(Service, (ops) => ops.schedule(op, ...args)).pipe(Effect.withSpan("Operation.schedule"));
 var withInvocationOptions = (options) => Layer.effect(Service, Effect.gen(function* () {
   const service = yield* Service;
   return Service.of({
@@ -183,7 +180,10 @@ var withInvocationOptions = (options) => Layer.effect(Service, Effect.gen(functi
       ...options,
       ...invocationOptions
     }),
-    schedule: service.schedule
+    schedule: (op, input, invocationOptions) => service.schedule(op, input, {
+      ...options,
+      ...invocationOptions
+    })
   });
 }));
 var PersistentOperation_v0_1_0 = Schema$.Struct({
@@ -197,10 +197,7 @@ var PersistentOperation_v0_1_0 = Schema$.Struct({
   outputSchema: Schema$.optional(JsonSchema.JsonSchema),
   services: Schema$.optional(Schema$.Array(Schema$.String)),
   binding: Schema$.optional(Schema$.String)
-}).pipe(Type.object({
-  typename: "org.dxos.type.function",
-  version: "0.1.0"
-}));
+}).pipe(Type.makeObject(DXN.make("org.dxos.type.function", "0.1.0")));
 var _migration = Migration.define({
   from: PersistentOperation_v0_1_0,
   to: PersistentOperation,
@@ -225,11 +222,10 @@ var migrations = [
 
 export {
   make,
-  intrinsic,
   withHandler,
   PersistentOperation,
   deserialize,
   invoke,
   Operation_exports
 };
-//# sourceMappingURL=chunk-SEBWOTOU.mjs.map
+//# sourceMappingURL=chunk-OKWXDYEB.mjs.map

package/dist/lib/neutral/chunk-OKWXDYEB.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 { DXN, Annotation, JsonSchema, Migration, Obj, Ref, Type, type Key } from '@dxos/echo';\nimport type { URI } from '@dxos/keys';\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: DXN.DXN;\n    readonly name?: string;\n    readonly version?: string;\n    readonly description?: string;\n    /**\n     * Phosphor icon identifier in `ph--<name>--<variant>` format (e.g. `ph--file-text--regular`).\n     */\n    readonly icon?: 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     * Dictionary of annotations for the operation.\n     */\n    // TODO(dmaretskyi): Make required, but this complicates `make` to fill in defaults.\n    readonly annotations?: Annotation.Dictionary;\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/**\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 * 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 * The registry `key` and `version` live in the object meta — access via\n * `Obj.getMeta(record).key` and `Obj.getMeta(record).version`.\n */\nexport const PersistentOperation = Schema$.Struct({\n  name: Schema$.NonEmptyString,\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\n  /**\n   * Phosphor icon identifier in `ph--<name>--<variant>` format (e.g. `ph--file-text--regular`).\n   */\n  icon: Schema$.optional(Schema$.String),\n}).pipe(\n  Annotation.LabelAnnotation.set(['name']),\n  Annotation.IconAnnotation.set({ icon: 'ph--function--regular', hue: 'blue' }),\n  Annotation.HiddenAnnotation.set(true),\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.makeObject(DXN.make('org.dxos.type.function', '0.2.0')),\n);\nexport type PersistentOperation = Type.InstanceType<typeof PersistentOperation>;\n\nconst FUNCTION_META_KEY = 'org.dxos.service.function';\n\n/**\n * Get the registry key for a persistent operation record (from the object meta).\n */\nexport const getKey = (record: PersistentOperation): string | undefined => Obj.getMeta(record).key;\n\n/**\n * Get the registry version for a persistent operation record (from the object meta).\n */\nexport const getVersion = (record: PersistentOperation): string | undefined => Obj.getMeta(record).version;\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      key: operation.meta.key,\n      version: operation.meta.version ?? '0.0.0',\n      keys: operation.meta.deployedId ? [{ source: FUNCTION_META_KEY, id: operation.meta.deployedId }] : [],\n      annotations: operation.meta.annotations,\n    },\n    name: operation.meta.name ?? '',\n    description: operation.meta.description,\n    icon: operation.meta.icon,\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  const meta = Obj.getMeta(record);\n  // Extract deployed function ID from ECHO meta keys (matches FUNCTIONS_META_KEY in @dxos/functions).\n  const deployedId = meta.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: DXN.tryMake(meta.key ?? record.name) ?? DXN.make(meta.key ?? record.name),\n      name: record.name,\n      version: meta.version ?? '0.0.0',\n      description: record.description,\n      icon: record.icon,\n      deployedId,\n      annotations: meta.annotations ?? {},\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.name = source.name ?? target.name;\n    target.description = source.description;\n    target.icon = source.icon;\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    const sourceMeta = Obj.getMeta(source);\n    const targetMeta = Obj.getMeta(target);\n    targetMeta.key = sourceMeta.key ?? targetMeta.key;\n    targetMeta.version = sourceMeta.version;\n    // Only overwrite foreign keys when the source actually carries them; otherwise we'd wipe\n    // bindings (e.g. the deployedId set by `deserialize`) on records produced by `serialize`.\n    if (sourceMeta.keys.length > 0) {\n      targetMeta.keys = JSON.parse(JSON.stringify(sourceMeta.keys));\n    }\n    targetMeta.annotations = sourceMeta.annotations ?? targetMeta.annotations;\n  });\n};\n\n/**\n * Translatable label — a plain string or an i18next-style `[key, options]` tuple.\n * Defined locally to avoid a core dependency on UI translation packages; structurally compatible with\n * the app-level `Label` type so values flow into UI toasts unchanged.\n */\nexport type Label = string | [string, { ns: string | readonly string[]; count?: number; defaultValue?: string }];\n\n/**\n * Per-phase user notification messages for an invocation.\n * A phase is notified to the user iff its message is provided; messages are translatable {@link Label}s.\n */\nexport interface NotifyOptions {\n  /** Shown when the invocation starts. */\n  start?: Label;\n  /** Shown when the invocation succeeds. */\n  success?: Label;\n  /** Shown when the invocation fails. */\n  error?: Label;\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   * Request user-facing notifications at the given invocation phases.\n   */\n  notify?: NotifyOptions;\n  /**\n   * URI of the conversation feed (queue) — today always an EID, but typed as\n   * `URI.URI` to accommodate future entity-kind extensions. Narrow with `EID.parse`\n   * at the point of use.\n   * Passed to the process environment so nested operations can resolve AiContext.Service and related services.\n   */\n  conversation?: URI.URI;\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, options?: InvokeOptions] : [input: I, options?: InvokeOptions]\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, options?: InvokeOptions] : [input: I, options?: InvokeOptions]\n): Effect.Effect<void, never, Service> =>\n  Effect.flatMap(Service, (ops) => ops.schedule(op, ...(args as [I, InvokeOptions?]))).pipe(\n    Effect.withSpan('Operation.schedule'),\n  );\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: ((op: Operation.Definition.Any, input: any, invocationOptions: InvokeOptions) =>\n          service.schedule(op, input, { ...options, ...invocationOptions })) as any,\n      });\n    }),\n  );\n\n//\n// Legacy schemas and migrations.\n//\n\n/**\n * Persistent operation schema v0.1.0 — `key` and `version` are stored as data properties.\n * @deprecated Use {@link PersistentOperation} (v0.2.0) instead; the `key` and `version` now live in the object meta.\n */\nexport const PersistentOperation_v0_1_0 = Schema$.Struct({\n  key: Schema$.optional(Schema$.String),\n  name: Schema$.NonEmptyString,\n  version: Schema$.String,\n  description: Schema$.optional(Schema$.String),\n  updated: Schema$.optional(Schema$.String),\n  source: Schema$.optional(Ref.Ref(Obj.Unknown)),\n  inputSchema: Schema$.optional(JsonSchema.JsonSchema),\n  outputSchema: Schema$.optional(JsonSchema.JsonSchema),\n  services: Schema$.optional(Schema$.Array(Schema$.String)),\n  binding: Schema$.optional(Schema$.String),\n}).pipe(Type.makeObject(DXN.make('org.dxos.type.function', '0.1.0')));\nexport type PersistentOperation_v0_1_0 = Type.InstanceType<typeof PersistentOperation_v0_1_0>;\n\n/**\n * Migration from {@link PersistentOperation_v0_1_0} (v0.1.0) to {@link PersistentOperation} (v0.2.0).\n * Moves `key` and `version` from the data section into the object meta.\n */\nconst _migration = Migration.define({\n  from: PersistentOperation_v0_1_0,\n  to: PersistentOperation,\n  transform: async (from) => ({\n    [Obj.Meta]: { key: from.key, version: from.version },\n    name: from.name,\n    description: from.description,\n    updated: from.updated,\n    source: from.source as any,\n    inputSchema: from.inputSchema,\n    outputSchema: from.outputSchema,\n    services: from.services,\n    binding: from.binding,\n  }),\n});\n\n/**\n * Schema migrations exported by this module.\n * Exported as an array for extensibility — append future versions here.\n */\nexport const migrations = [_migration];\n"],
+  "mappings": "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",
+  "names": ["Context", "Effect", "Layer", "Pipeable", "Schema$", "DXN", "Annotation", "JsonSchema", "Migration", "Obj", "Ref", "Type", "DefinitionTypeId", "isOperationDefinition", "value", "isOperationWithHandler", "make", "props", "executionMode", "types", "services", "pipe", "pipeArguments", "arguments", "withHandler", "opOrHandler", "handler", "undefined", "handlerFn", "op", "opaqueHandler", "PersistentOperation", "Struct", "name", "NonEmptyString", "description", "optional", "String", "updated", "source", "Unknown", "inputSchema", "outputSchema", "Array", "binding", "icon", "LabelAnnotation", "set", "IconAnnotation", "hue", "HiddenAnnotation", "makeObject", "FUNCTION_META_KEY", "getKey", "record", "getMeta", "key", "getVersion", "version", "serialize", "operation", "Meta", "meta", "keys", "deployedId", "id", "annotations", "toJsonSchema", "input", "output", "map", "service", "deserialize", "find", "toEffectSchema", "GenericTag", "tryMake", "setFrom", "target", "update", "JSON", "parse", "stringify", "sourceMeta", "targetMeta", "length", "Service", "Tag", "invoke", "args", "flatMap", "ops", "withSpan", "schedule", "withInvocationOptions", "options", "effect", "gen", "of", "invocationOptions", "invokePromise", "PersistentOperation_v0_1_0", "_migration", "define", "from", "to", "transform", "migrations"]
+}

package/dist/lib/neutral/{chunk-LRCABAWU.mjs → chunk-T43BXITP.mjs}

@@ -1,9 +1,9 @@
 import {
   Sleep
-} from "./chunk-VSICPGGY.mjs";
+} from "./chunk-DC4S2HKY.mjs";
 import {
   withHandler
-} from "./chunk-SEBWOTOU.mjs";
+} from "./chunk-OKWXDYEB.mjs";
 
 // src/testing/sleep.ts
 import * as Effect from "effect/Effect";
@@ -14,4 +14,4 @@ var sleep_default = Sleep.pipe(withHandler(Effect.fn(function* ({ duration = 1e5
 export {
   sleep_default
 };
-//# sourceMappingURL=chunk-LRCABAWU.mjs.map
+//# sourceMappingURL=chunk-T43BXITP.mjs.map

package/dist/lib/neutral/fib-CAER5YCY.mjs

@@ -0,0 +1,10 @@
+import {
+  fib_default
+} from "./chunk-HXPMSLL7.mjs";
+import "./chunk-DC4S2HKY.mjs";
+import "./chunk-OKWXDYEB.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  fib_default as default
+};
+//# sourceMappingURL=fib-CAER5YCY.mjs.map