@dxos/compute 0.9.1-staging.ee54ba693a → 0.11.0

package/dist/lib/chunk-OperationHandlerSet.mjs

@@ -0,0 +1,660 @@
+import { t as __exportAll } from "./chunk-rolldown-runtime.mjs";
+import { BaseError } from "@dxos/errors";
+import * as Schema from "effect/Schema";
+import { Annotation, DXN, JsonSchema, Migration, Obj, Ref, Type } from "@dxos/echo";
+import * as Effect from "effect/Effect";
+import { assertArgument } from "@dxos/invariant";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Pipeable from "effect/Pipeable";
+import { pipe } from "effect/Function";
+import { EffectEx } from "@dxos/effect";
+import { DXN as DXN$1 } from "@dxos/keys";
+//#region src/errors.ts
+/**
+* Raised when a function wants to yield to the scheduler to not exceed platform limits.
+* The scheduler will re-run the function after the yield.
+* It is assumed that the function can be retried with the same input.
+* The function might have produced side-effects on the first run.
+*/
+var RunAgainError = class extends BaseError.extend("RunAgainError", "Run again") {};
+var InvokerNotInitializedError = class extends BaseError.extend("InvokerNotInitializedError", "Invoker not initialized") {};
+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 },
+			message: `Service not available: ${service}`,
+			...options
+		});
+	}
+};
+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") {};
+/**
+* Raised when the upstream AI gateway responds with a structured JSON error envelope
+* (`{ "type": "error", "error": { "type": ..., "message": ... } }`). Surfaces as a typed
+* defect from `FunctionsAiHttpClient`, bypassing `@effect/ai`'s generic `HttpResponseError`
+* wrapping so callers can match on the error class directly.
+*/
+var FunctionsAiUpstreamError = class extends BaseError.extend("FunctionsAiUpstreamError", "Upstream AI service returned an error") {};
+/**
+* Specialized `FunctionsAiUpstreamError` for the memoization layer: the recorded fixture for a
+* given cache key was not found and `ALLOW_LLM_GENERATION` is unset. The `cacheKey` is exposed
+* via `context.cacheKey` to make regeneration straightforward.
+*/
+var FunctionsAiMemoizationMissError = class extends BaseError.extend("FunctionsAiMemoizationMissError", "No memoized AI conversation found for the given cache key") {};
+//#endregion
+//#region src/Operation.ts
+var Operation_exports = /* @__PURE__ */ __exportAll({
+	DefinitionTypeId: () => DefinitionTypeId,
+	IdempotentAnnotation: () => IdempotentAnnotation,
+	Label: () => Label,
+	McpTool: () => McpTool,
+	McpToolAnnotation: () => McpToolAnnotation,
+	NotifyOptions: () => NotifyOptions,
+	NotifyOptionsAnnotation: () => NotifyOptionsAnnotation,
+	PersistentOperation: () => PersistentOperation,
+	PersistentOperation_v0_1_0: () => PersistentOperation_v0_1_0,
+	Service: () => Service,
+	VisibleAnnotation: () => VisibleAnnotation,
+	annotate: () => annotate,
+	deserialize: () => deserialize,
+	getKey: () => getKey,
+	getMcpTool: () => getMcpTool,
+	getVersion: () => getVersion,
+	idempotent: () => idempotent,
+	invoke: () => invoke,
+	isIdempotent: () => isIdempotent,
+	isOperationDefinition: () => isOperationDefinition,
+	isOperationWithHandler: () => isOperationWithHandler,
+	isVisible: () => isVisible,
+	make: () => make$1,
+	mcpTool: () => mcpTool,
+	migrations: () => migrations,
+	opaqueHandler: () => opaqueHandler,
+	prepare: () => prepare,
+	runAgain: () => runAgain,
+	schedule: () => schedule,
+	serialize: () => serialize,
+	setFrom: () => setFrom,
+	visible: () => visible,
+	withHandler: () => withHandler,
+	withInvocationOptions: () => withInvocationOptions
+});
+var DefinitionTypeId = "~@dxos/operation/OperationDefinition";
+/**
+* Checks if a value is an operation definition.
+*/
+var isOperationDefinition = (value) => {
+	return typeof value === "object" && value !== null && "~@dxos/operation/OperationDefinition" in value;
+};
+/**
+* Checks if a value is an operation with a handler.
+*/
+var isOperationWithHandler = (value) => {
+	return isOperationDefinition(value) && "handler" in value;
+};
+/**
+* Creates a new Operation definition.
+* Applies default executionMode of 'async' if not specified.
+* The returned type preserves the literal types of props (including services).
+*/
+var make$1 = (props) => {
+	return {
+		[DefinitionTypeId]: {},
+		...props,
+		executionMode: props.executionMode ?? "async",
+		types: props.types ?? [],
+		services: props.services ?? [],
+		pipe() {
+			return Pipeable.pipeArguments(this, arguments);
+		}
+	};
+};
+/**
+* Attaches a handler to an Operation definition.
+* The handler may use any services declared in the operation, plus Operation.Service (always available).
+* Dual API: can be called directly or used in a pipe.
+*
+* @example
+* ```ts
+* const MyOp = Operation.make({
+*   input: Schema.Void,
+*   output: Schema.Void,
+*   meta: { key: 'my-op' },
+*   services: [DatabaseService],
+* });
+*
+* // Direct call - handler can use DatabaseService
+* const op = Operation.withHandler(MyOp, (input) =>
+*   Effect.gen(function* () {
+*     const db = yield* DatabaseService;
+*     return {};
+*   }),
+* );
+*
+* // Piped call
+* const op = MyOp.pipe(Operation.withHandler((input) => Effect.succeed({})));
+* ```
+*/
+var withHandler = (opOrHandler, handler) => {
+	if (handler === void 0) {
+		const handlerFn = opOrHandler;
+		return ((op) => ({
+			...op,
+			handler: handlerFn
+		}));
+	}
+	return {
+		...opOrHandler,
+		handler
+	};
+};
+/**
+* Helper to make the handler type opaque.
+* Workaround for TypeScript's inability to infer the handler type from the operation definition:
+* ```
+* error TS2742: The inferred type of 'default' cannot be named without a reference.
+* ```
+*
+* Most of the time the exact handler type is not needed.
+*
+* @example
+* ```ts
+* const MyOp = Operation.make({
+*   input: Schema.Void,
+*   output: Schema.Void,
+*   meta: { key: 'my-op' },
+*   services: [DatabaseService],
+* });
+*
+* export default MyOp.pipe(
+*   Operation.withHandler(
+*     Effect.fn(function* (input) {
+*       return { result: 'ok' };
+*     }),
+*   ),
+*   Operation.opaqueHandler,
+* );
+* ```
+*/
+var opaqueHandler = (handler) => handler;
+/**
+* Database record of an operation.
+* The registry `key` and `version` live in the object meta — access via
+* `Obj.getMeta(record).key` and `Obj.getMeta(record).version`.
+*/
+var PersistentOperation = class extends Type.makeObject(DXN.make("org.dxos.type.function", "0.2.0"))(Schema.Struct({
+	name: Schema.NonEmptyString,
+	description: Schema.optional(Schema.String),
+	/**
+	* ISO date string of the last deployment.
+	*/
+	updated: Schema.optional(Schema.String),
+	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 services the operation handler declares.
+	*/
+	services: Schema.optional(Schema.Array(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(Annotation.LabelAnnotation.set(["name"]), Annotation.IconAnnotation.set({
+	icon: "ph--function--regular",
+	hue: "blue"
+}), Annotation.HiddenAnnotation.set(true))) {};
+var FUNCTION_META_KEY = "org.dxos.service.function";
+/**
+* Get the registry key for a persistent operation record (from the object meta).
+*/
+var getKey = (record) => Obj.getMeta(record).key;
+/**
+* Get the registry version for a persistent operation record (from the object meta).
+*/
+var getVersion = (record) => Obj.getMeta(record).version;
+/**
+* Serialize an operation definition to a persistent operation record.
+*/
+var serialize = (operation) => {
+	return Obj.make(PersistentOperation, {
+		[Obj.Meta]: {
+			key: operation.meta.key,
+			version: operation.meta.version ?? "0.0.0",
+			keys: operation.meta.deployedId ? [{
+				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),
+		outputSchema: JsonSchema.toJsonSchema(operation.output),
+		services: operation.services.map((service) => service.key)
+	});
+};
+/**
+* Deserialize a persistent operation record to an operation definition.
+*/
+var deserialize = (record) => {
+	const meta = Obj.getMeta(record);
+	const deployedId = meta.keys.find((key) => key.source === FUNCTION_META_KEY)?.id;
+	return make$1({
+		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: DXN.tryMake(meta.key ?? record.name) ?? DXN.make(meta.key ?? record.name),
+			name: record.name,
+			version: meta.version ?? "0.0.0",
+			description: record.description,
+			icon: record.icon,
+			deployedId,
+			annotations: meta.annotations ?? {}
+		}
+	});
+};
+/**
+* Update properties on the target operation record from the source operation record.
+*/
+var setFrom = (target, source) => {
+	Obj.update(target, (target) => {
+		target.name = source.name ?? target.name;
+		target.description = source.description;
+		target.icon = source.icon;
+		target.updated = source.updated;
+		target.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : void 0;
+		target.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : void 0;
+		const sourceMeta = Obj.getMeta(source);
+		const targetMeta = Obj.getMeta(target);
+		targetMeta.key = sourceMeta.key ?? targetMeta.key;
+		targetMeta.version = sourceMeta.version;
+		if (sourceMeta.keys.length > 0) targetMeta.keys = JSON.parse(JSON.stringify(sourceMeta.keys));
+		targetMeta.annotations = sourceMeta.annotations ?? targetMeta.annotations;
+	});
+};
+/**
+* Translatable label — a plain string or an i18next-style `[key, options]` tuple.
+* Defined locally to avoid a core dependency on UI translation packages; structurally compatible with
+* the app-level `Label` type so values flow into UI toasts unchanged.
+*/
+var Label = Schema.Union(Schema.String, Schema.mutable(Schema.Tuple(Schema.String, Schema.mutable(Schema.Struct({
+	ns: Schema.String,
+	count: Schema.optional(Schema.Number),
+	defaultValue: Schema.optional(Schema.String)
+})))));
+/**
+* Per-phase user notification messages for an invocation.
+* A phase is notified to the user iff its message is provided; messages are translatable {@link Label}s.
+*/
+var NotifyOptions = Schema.Struct({
+	/** Shown when the invocation starts. */
+	start: Schema.optional(Label),
+	/** Shown when the invocation succeeds. */
+	success: Schema.optional(Label),
+	/** Shown when the invocation fails. */
+	error: Schema.optional(Label)
+});
+/**
+* Annotation that configures the process to notify the user at the given invocation phases.
+*/
+var NotifyOptionsAnnotation = Annotation.make({
+	id: "org.dxos.operation.notify-options",
+	schema: NotifyOptions
+});
+/**
+* Builds a {@link SerializedInvocation} from a live {@link Definition} and its input — the serializable
+* counterpart to a direct `invoke`, for describing an invocation that must cross a serialization
+* boundary (e.g. a deferred toast action). Resolve it later with `OperationHandlerSet.getHandlerByKey`.
+*/
+var prepare = (operation, input) => ({
+	operation: operation.meta.key,
+	input
+});
+/**
+* Annotation that marks an operation as idempotent — safe to retry even if a previous execution
+* was interrupted mid-handler. When absent the operation is treated as non-idempotent, and the
+* process runtime will fail (rather than re-run) any handler that was interrupted.
+*/
+var IdempotentAnnotation = Annotation.make({
+	id: "org.dxos.operation.idempotent",
+	schema: Schema.Boolean
+});
+/**
+* Returns true when the operation is explicitly annotated as idempotent.
+*/
+var isIdempotent = (op) => op.meta.annotations ? Option.getOrElse(Annotation.getDictionary(op.meta.annotations, IdempotentAnnotation), () => false) : false;
+/**
+* Attaches an annotation to an operation definition, returning a new definition.
+* Combinators never mutate their input — operation definitions are module-level singletons
+* shared across handler sets, skills, and the registry, so a fresh value keeps the
+* annotated definition distinct from any other reference to the original.
+*
+* Type-preserving: an annotation does not change the operation's input/output/service types, so the
+* returned definition keeps `Def` (preserving `withHandler` inference and downstream usage).
+*/
+var annotate = (annotation, value) => (op) => {
+	const annotations = { ...op.meta.annotations ?? {} };
+	Annotation.setDictionary(annotations, annotation, value);
+	return {
+		...op,
+		meta: {
+			...op.meta,
+			annotations
+		}
+	};
+};
+/**
+* Marks an operation as visible on user-facing operation surfaces (trigger/automation pickers,
+* manual invocation). Absent ⇒ internal: invoked programmatically by plugins and hidden from pickers.
+*
+* Polarity is inverted from the schema-level `HiddenAnnotation` (default visible): operations are
+* hidden by default, since most are internal plugin machinery and only a minority are user-facing.
+*/
+var VisibleAnnotation = Annotation.make({
+	id: "org.dxos.operation.visible",
+	schema: Schema.Boolean
+});
+/**
+* Pipeable combinator that marks an operation visible. Apply at the definition site:
+* `Operation.make({ ... }).pipe(Operation.visible)`.
+*/
+var visible = annotate(VisibleAnnotation, true);
+/**
+* Returns true when an operation is annotated as visible on user-facing surfaces (trigger/automation
+* pickers, manual invocation). Reads from the persisted operation — the form every consumer holds.
+*/
+var isVisible = (op) => Option.getOrElse(Annotation.get(op, VisibleAnnotation), () => false);
+/**
+* Projection marker for an operation exposed as an MCP tool to external agents.
+* See plugin-projects `MILESTONE-5.md` §7.4 for the full contract.
+*/
+var McpTool = Schema.Struct({
+	/** Tool name as exposed to MCP clients; camelCase, domain-prefixed (e.g. `taskCreate`). */
+	name: Schema.String,
+	/** Model-facing description; falls back to the operation's own description when absent. */
+	description: Schema.optional(Schema.String),
+	/**
+	* Safety class the server maps to MCP tool hints: `read` is side-effect free (readOnlyHint),
+	* `write` mutates space data, `destructive` deletes or is otherwise irreversible.
+	*/
+	safety: Schema.Literal("read", "write", "destructive"),
+	/** Aspect/toolset, for server-side filtering (e.g. `/mcp?toolsets=tasks`). */
+	aspect: Schema.optional(Schema.String)
+});
+/**
+* Annotation that opts an operation into MCP projection. The annotation rides through
+* {@link serialize} into the persisted record, so a remote projector (edge mcp-space-service)
+* discovers tools from the operation registry rather than a hand-maintained table.
+*
+* Projected operations must be remotely invocable: refs (not live objects) in, JSON snapshots
+* out, schemas that survive serialization, and worker-safe handlers — MILESTONE-5.md §7.4.
+*/
+var McpToolAnnotation = Annotation.make({
+	id: "org.dxos.operation.mcp-tool",
+	schema: McpTool
+});
+/**
+* Pipeable combinator that opts an operation into MCP projection. Apply at the definition site:
+* `Operation.make({ ... }).pipe(Operation.mcpTool({ name: 'taskComplete', safety: 'write' }))`.
+*/
+var mcpTool = (props) => annotate(McpToolAnnotation, props);
+/**
+* Returns the MCP projection descriptor when the operation is annotated for it, else undefined.
+* Reads from the persisted operation — the form the projector holds.
+*/
+var getMcpTool = (op) => Option.getOrUndefined(Annotation.get(op, McpToolAnnotation));
+/**
+* Pipeable combinator that marks an operation idempotent — see {@link IdempotentAnnotation}. Apply at
+* the definition site: `Operation.make({ ... }).pipe(Operation.idempotent)`.
+*/
+var idempotent = annotate(IdempotentAnnotation, true);
+/**
+* Context tag for the Operation service.
+* Operation handlers can yield this to invoke other operations or schedule followups.
+*
+* @example
+* ```ts
+* const handler = (input) => Effect.gen(function* () {
+*   // Schedule a followup (fire and forget)
+*   yield* Operation.schedule(AnalyticsOperation, { event: 'completed' });
+*
+*   // Invoke another operation
+*   return yield* Operation.invoke(OtherOperation, { data: input.data });
+* });
+* ```
+*/
+var Service = class extends Context.Tag("@dxos/operation/Service")() {};
+/**
+* Invoke an operation as an Effect.
+* Yields the Operation.Service internally.
+*
+* @example
+* ```ts
+* yield* Operation.invoke(MyOperation, { data: 'test' });
+* ```
+*/
+var invoke = (op, ...args) => Effect.flatMap(Service, (ops) => ops.invoke(op, ...args)).pipe(Effect.withSpan("Operation.invoke"));
+/**
+* Schedule an operation to run as a followup.
+* Yields the Operation.Service internally.
+*
+* @example
+* ```ts
+* yield* Operation.schedule(AnalyticsOperation, { event: 'completed' });
+* yield* Operation.schedule(VoidOperation); // input optional when void
+* ```
+*/
+var schedule = (op, ...args) => Effect.flatMap(Service, (ops) => ops.schedule(op, ...args)).pipe(Effect.withSpan("Operation.schedule"));
+/**
+* Call inside an operation to stop the current invocation and have the system re-run it (e.g. a capped
+* sync run with more work left). Surfaces as a {@link RunAgainError} defect; the trigger dispatcher
+* re-queues the same event FIFO to continue. A caller invoking via `Operation.invoke` directly gets the
+* defect and does not auto-continue.
+*/
+var runAgain = () => Effect.failCauseSync(() => Cause.die(new RunAgainError()));
+/**
+* Provides additional invocation options to all invocations.
+*/
+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: ((op, input, invocationOptions) => service.schedule(op, input, {
+			...options,
+			...invocationOptions
+		}))
+	});
+}));
+/**
+* Persistent operation schema v0.1.0 — `key` and `version` are stored as data properties.
+* @deprecated Use {@link PersistentOperation} (v0.2.0) instead; the `key` and `version` now live in the object meta.
+*/
+var PersistentOperation_v0_1_0 = class extends Type.makeObject(DXN.make("org.dxos.type.function", "0.1.0"))(Schema.Struct({
+	key: Schema.optional(Schema.String),
+	name: Schema.NonEmptyString,
+	version: Schema.String,
+	description: Schema.optional(Schema.String),
+	updated: Schema.optional(Schema.String),
+	source: Schema.optional(Ref.Ref(Obj.Unknown)),
+	inputSchema: Schema.optional(JsonSchema.JsonSchema),
+	outputSchema: Schema.optional(JsonSchema.JsonSchema),
+	services: Schema.optional(Schema.Array(Schema.String)),
+	binding: Schema.optional(Schema.String)
+})) {};
+/**
+* Schema migrations exported by this module.
+* Exported as an array for extensibility — append future versions here.
+*/
+var migrations = [Migration.define({
+	from: PersistentOperation_v0_1_0,
+	to: PersistentOperation,
+	transform: async (from) => ({
+		[Obj.Meta]: {
+			key: from.key,
+			version: from.version
+		},
+		name: from.name,
+		description: from.description,
+		updated: from.updated,
+		source: from.source,
+		inputSchema: from.inputSchema,
+		outputSchema: from.outputSchema,
+		services: from.services,
+		binding: from.binding
+	})
+})];
+//#endregion
+//#region src/OperationHandlerSet.ts
+var OperationHandlerSet_exports = /* @__PURE__ */ __exportAll({
+	OperationHandlerProvider: () => OperationHandlerProvider,
+	TypeId: () => TypeId,
+	async: () => async,
+	empty: () => empty,
+	getHandler: () => getHandler,
+	getHandlerByKey: () => getHandlerByKey,
+	isOperationHandlerSet: () => isOperationHandlerSet,
+	lazy: () => lazy,
+	make: () => make,
+	merge: () => merge,
+	provide: () => provide,
+	reactive: () => reactive
+});
+var TypeId = "~@dxos/operation/OperationHandlerSet";
+var isOperationHandlerSet = (value) => {
+	return typeof value === "object" && value !== null && "~@dxos/operation/OperationHandlerSet" in value;
+};
+var empty = {
+	[TypeId]: TypeId,
+	handlers: Effect.succeed([]),
+	getHandlers: () => Promise.resolve([])
+};
+/**
+* Creates a new operation handler set from a list of handlers.
+*
+* @example
+* ```ts
+* const set = OperationHandlerSet.make(
+*   Operation.withHandler(Operation.make({ input: Schema.Void, output: Schema.Void }), (input) => Effect.succeed({})),
+*   Operation.withHandler(Operation.make({ input: Schema.Void, output: Schema.Void }), (input) => Effect.succeed({})),
+* );
+* ```
+*/
+var make = (...handlers) => {
+	return async(() => Promise.resolve(handlers));
+};
+var async = (getHandlers) => {
+	let promise = null;
+	const getHandlersCached = () => {
+		if (!promise) promise = getHandlers();
+		return promise;
+	};
+	return {
+		[TypeId]: TypeId,
+		getHandlers,
+		handlers: Effect.promise(getHandlersCached)
+	};
+};
+/**
+* Builds a set backed by an atom of contributed sets. The merged result is
+* cached and invalidated whenever the atom changes, so most accesses are
+* cheap but newly registered handlers are picked up.
+*/
+var reactive = (registry, atom) => {
+	let cached = null;
+	registry.subscribe(atom, () => {
+		cached = null;
+	});
+	const compute = Effect.suspend(() => pipe(registry.get(atom), Effect.forEach((set) => set.handlers, { concurrency: "unbounded" }), Effect.map((groups) => groups.flat()), Effect.tapErrorCause(() => Effect.sync(() => {
+		cached = null;
+	}))));
+	const getHandlers = () => cached ??= EffectEx.runAndForwardErrors(compute);
+	return {
+		[TypeId]: TypeId,
+		getHandlers,
+		handlers: Effect.promise(getHandlers)
+	};
+};
+/**
+* Merges multiple operation handler sets into a single set.
+*
+*/
+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()));
+};
+/**
+* Creates a new operation handler set from a list of lazy-loaded modules.
+*
+* @example
+* ```ts
+* const set = OperationHandlerSet.lazy(
+*   () => import('./my-handler'),
+*   () => import('./my-other-handler'),
+* );
+* ```
+*/
+var lazy = (...modules) => {
+	return async(() => Promise.all(modules.map((module) => module().then(({ default: handler }) => handler))));
+};
+/**
+* Gets a handler for an operation by definition.
+*/
+var getHandler = (set, definition) => Effect.gen(function* () {
+	const handler = (yield* set.handlers).find((handler) => handler.meta.key === definition.meta.key);
+	if (!handler) return yield* Effect.fail(new NoHandlerError(definition.meta.key));
+	return handler;
+});
+/**
+* Gets a handler for an operation by key.
+* Accepts either a plain NSID (`org.dxos.function.database.contextAdd`) or a
+* full DXN string (`dxn:org.dxos.function.database.contextAdd`).
+*/
+var getHandlerByKey = (set, key) => Effect.gen(function* () {
+	const handlers = yield* set.handlers;
+	const normalizeKey = (k) => DXN$1.isDXN(k) ? DXN$1.getName(k) : k;
+	const normalizedKey = normalizeKey(key);
+	const handler = handlers.find((handler) => normalizeKey(handler.meta.key) === normalizedKey);
+	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);
+//#endregion
+export { RunAgainError as C, NoHandlerError as S, TriggerStateNotFoundError as T, FunctionsAiMemoizationMissError as _, lazy as a, InvalidOperationOutputError as b, PersistentOperation as c, invoke as d, isIdempotent as f, FunctionNotFoundError as g, FunctionError as h, getHandlerByKey as i, Service as l, withHandler as m, OperationHandlerSet_exports as n, NotifyOptions as o, make$1 as p, getHandler as r, Operation_exports as s, OperationHandlerProvider as t, deserialize as u, FunctionsAiUpstreamError as v, ServiceNotAvailableError as w, InvokerNotInitializedError as x, InvalidOperationInputError as y };
+
+//# sourceMappingURL=chunk-OperationHandlerSet.mjs.map