@dxos/compute 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

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

@@ -0,0 +1,235 @@
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Operation.ts
+var Operation_exports = {};
+__export(Operation_exports, {
+  DefinitionTypeId: () => DefinitionTypeId,
+  PersistentOperation: () => PersistentOperation,
+  PersistentOperation_v0_1_0: () => PersistentOperation_v0_1_0,
+  Service: () => Service,
+  deserialize: () => deserialize,
+  getKey: () => getKey,
+  getVersion: () => getVersion,
+  intrinsic: () => intrinsic,
+  invoke: () => invoke,
+  isOperationDefinition: () => isOperationDefinition,
+  isOperationWithHandler: () => isOperationWithHandler,
+  make: () => make,
+  migrations: () => migrations,
+  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, Migration, 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({
+  name: Schema$.NonEmptyString,
+  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.2.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 getKey = (record) => Obj.getMeta(record).key;
+var getVersion = (record) => Obj.getMeta(record).version;
+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
+        }
+      ] : []
+    },
+    name: operation.meta.name ?? "",
+    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 meta = Obj.getMeta(record);
+  const deployedId = meta.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: meta.key ?? record.name,
+      name: record.name,
+      version: meta.version ?? "0.0.0",
+      description: record.description,
+      deployedId
+    }
+  });
+};
+var setFrom = (target, source) => {
+  Obj.update(target, (target2) => {
+    target2.name = source.name ?? target2.name;
+    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;
+    const sourceMeta = Obj.getMeta(source);
+    const targetMeta = Obj.getMeta(target2);
+    targetMeta.key = sourceMeta.key ?? targetMeta.key;
+    targetMeta.version = sourceMeta.version;
+    if (sourceMeta.keys.length > 0) {
+      targetMeta.keys = JSON.parse(JSON.stringify(sourceMeta.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
+  });
+}));
+var PersistentOperation_v0_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)
+}).pipe(Type.object({
+  typename: "org.dxos.type.function",
+  version: "0.1.0"
+}));
+var _migration = 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
+  })
+});
+var migrations = [
+  _migration
+];
+
+export {
+  make,
+  intrinsic,
+  withHandler,
+  PersistentOperation,
+  deserialize,
+  invoke,
+  Operation_exports
+};
+//# sourceMappingURL=chunk-SEBWOTOU.mjs.map

package/dist/lib/neutral/chunk-SEBWOTOU.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, Migration, 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 * 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}).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.2.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 * 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    },\n    name: operation.meta.name ?? '',\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  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: meta.key ?? record.name,\n      name: record.name,\n      version: meta.version ?? '0.0.0',\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.name = source.name ?? target.name;\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    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  });\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 AiContext.Service 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\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(\n  Type.object({\n    typename: 'org.dxos.type.function',\n    version: '0.1.0',\n  }),\n);\nexport interface PersistentOperation_v0_1_0 extends Schema$.Schema.Type<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$", "Annotation", "JsonSchema", "Migration", "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", "name", "NonEmptyString", "description", "optional", "String", "updated", "source", "Unknown", "inputSchema", "outputSchema", "Array", "binding", "object", "typename", "version", "LabelAnnotation", "set", "IconAnnotation", "icon", "hue", "SystemTypeAnnotation", "FUNCTION_META_KEY", "getKey", "record", "getMeta", "getVersion", "serialize", "operation", "Meta", "keys", "id", "toJsonSchema", "input", "output", "map", "service", "deserialize", "find", "toEffectSchema", "GenericTag", "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-VSICPGGY.mjs

@@ -0,0 +1,53 @@
+import {
+  intrinsic,
+  make
+} from "./chunk-SEBWOTOU.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-VSICPGGY.mjs.map

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

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

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

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

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

@@ -0,0 +1,10 @@
+import {
+  fib_default
+} from "./chunk-AKVCVI6N.mjs";
+import "./chunk-VSICPGGY.mjs";
+import "./chunk-SEBWOTOU.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  fib_default as default
+};
+//# sourceMappingURL=fib-ZSJYREBW.mjs.map

package/dist/lib/neutral/fib-ZSJYREBW.mjs.map

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