@dxos/compute 0.9.0 → 0.9.1-staging.ee54ba693a

package/src/Trigger.ts

@@ -7,10 +7,12 @@
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { DXN, Annotation, Feed, Obj, QueryAST, Ref, Type, type Query } from '@dxos/echo';
+import { Annotation, DXN, Feed, Obj, type Query, QueryAST, Ref, Type } from '@dxos/echo';
 import { HiddenAnnotation } from '@dxos/echo/Annotation';
 import { OptionsAnnotationId } from '@dxos/echo/Format';
 
+import * as Runnable from './Runnable';
+
 /**
  * Type discriminator for TriggerType.
  * Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.
@@ -51,10 +53,13 @@ export const specFeed = (feed: Feed.Feed): FeedSpec => ({
  */
 export const SubscriptionSpec = Schema.Struct({
   kind: Schema.Literal('subscription').annotations(kindLiteralAnnotations),
+
+  // TODO(burdon): Issue.
   query: Schema.Struct({
     raw: Schema.optional(Schema.String.annotations({ title: 'Query' })),
     ast: QueryAST.Query,
   }),
+
   options: Schema.optional(
     Schema.Struct({
       // Watch changes to object (not just creation).
@@ -139,58 +144,58 @@ export const Spec = Schema.Union(EmailSpec, FeedSpec, SubscriptionSpec, TimerSpe
 export type Spec = Schema.Schema.Type<typeof Spec>;
 
 /**
- * Function trigger.
- * Function is invoked with the `payload` passed as input data.
- * The event that triggers the function is available in the function context.
+ * Forms the input data passed to the function.
+ * Must match the function's input schema.
+ *
+ * @example
+ * {
+ *   item: '{{event.item}}',
+ *   instructions: 'Summarize and perform entity-extraction'
+ *   mailbox: { '/': 'echo://AAA/ZZZ' }
+ * }
  */
-const TriggerSchema = Schema.Struct({
-  /**
-   * Function or workflow to invoke.
-   */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema.optional(Ref.Ref(Obj.Unknown).annotations({ title: 'Function' })),
-
-  /**
-   * Only used for workflowSchema.
-   * Specifies the input node in the circuit.
-   * @deprecated Remove and enforce a single input node in all compute graphSchema.
-   */
-  inputNodeId: Schema.optional(Schema.String.annotations({ title: 'Input Node ID' })),
-
-  // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
-  //  Need lint rule; or agent rule to require PR review for "boolean" key word.
-  enabled: Schema.optional(Schema.Boolean.annotations({ title: 'Enabled' })),
-
-  spec: Schema.optional(Spec),
-
-  concurrency: Schema.optional(
-    Schema.Number.annotations({
-      title: 'Concurrency',
-      default: 1,
-      description:
-        'Maximum number of concurrent invocations of the trigger. For Feed triggers, this will process Feed items in parallel.',
-    }),
-  ),
+export const InputTemplate = Schema.Record({ key: Schema.String, value: Schema.Any });
 
-  /**
-   * Passed as the input data to the function.
-   * Must match the function's input schema.
-   *
-   * @example
-   * {
-   *   item: '{{event.item}}',
-   *   instructions: 'Summarize and perform entity-extraction'
-   *   mailbox: { '/': 'echo://AAA/ZZZ' }
-   * }
-   */
-  input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-}).pipe(
-  Annotation.IconAnnotation.set({ icon: 'ph--lightning--regular', hue: 'yellow' }),
-  HiddenAnnotation.set(true),
-  Type.makeObject(DXN.make('org.dxos.type.trigger', '0.1.0')),
-);
-
-export type Trigger = Type.InstanceType<typeof TriggerSchema>;
-export const Trigger: Type.Obj<Trigger> = TriggerSchema as any;
+/**
+ * Function trigger.
+ * Runnable is invoked with the `payload` passed as input data.
+ * The event that fires the trigger is available in the runnable context.
+ */
+export class Trigger extends Type.makeObject<Trigger>(DXN.make('org.dxos.type.trigger', '0.1.0'))(
+  Schema.Struct({
+    /**
+     * Runnable (operation or workflow) to invoke.
+     */
+    runnable: Schema.optional(Ref.Ref(Runnable.Runnable).annotations({ title: 'Runnable' })),
+    spec: Schema.optional(Spec),
+    enabled: Schema.optional(Schema.Boolean),
+
+    concurrency: Schema.Number.pipe(
+      Schema.annotations({
+        title: 'Concurrency',
+        default: 1,
+        description: 'Maximum number of concurrent invocations of the trigger.',
+      }),
+      Annotation.FormInputAnnotation.set(false),
+      Schema.optional,
+    ),
+
+    /**
+     * Only used for workflowSchema.
+     * Specifies the input node in the circuit.
+     * @deprecated Remove and enforce a single input node in all compute graphSchema.
+     */
+    inputNodeId: Schema.String.pipe(
+      Schema.annotations({ title: 'Input Node ID' }),
+      Annotation.FormInputAnnotation.set(false),
+      Schema.optional,
+    ),
+
+    /**
+     * Passed as the input data to the runnable.
+     */
+    input: InputTemplate.pipe(Annotation.FormInputAnnotation.set(false), Schema.optional),
+  }).pipe(Annotation.IconAnnotation.set({ icon: 'ph--lightning--regular', hue: 'yellow' }), HiddenAnnotation.set(true)),
+) {}
 
 export const make = (props: Obj.MakeProps<typeof Trigger>) => Obj.make(Trigger, props);

package/src/index.ts

@@ -4,16 +4,18 @@
 
 export * from './errors';
 
-export * as Blueprint from './Blueprint';
+export * as AgentService from './AgentService';
+export * as Skill from './Skill';
 export * as Credential from './Credential';
 export * as Header from './Header';
-export * as McpServer from './McpServer';
+export * as Instructions from './Instructions';
 export * as LayerSpec from './LayerSpec';
+export * as McpServer from './McpServer';
 export * as Operation from './Operation';
 export * as OperationHandlerSet from './OperationHandlerSet';
 export * as OperationRegistry from './OperationRegistry';
 export * as Process from './Process';
-export * as Routine from './Routine';
+export * as Runnable from './Runnable';
 export * as Script from './Script';
 export * as ServiceResolver from './ServiceResolver';
 export * as StorageService from './StorageService';

package/src/umbrella.test.ts

@@ -5,16 +5,17 @@
 import { describe, test } from 'vitest';
 
 import {
-  Blueprint,
   Credential,
   FunctionNotFoundError,
+  Instructions,
   Operation,
   OperationHandlerSet,
   OperationRegistry,
   Process,
-  Routine,
+  Runnable,
   Script,
   ServiceResolver,
+  Skill,
   StorageService,
   Template,
   Trace,
@@ -29,14 +30,15 @@ describe('umbrella re-exports', () => {
     expect(OperationHandlerSet).toBeDefined();
     expect(OperationRegistry).toBeDefined();
 
-    // Blueprint primitives.
-    expect(Blueprint).toBeDefined();
-    expect(Blueprint.make).toBeTypeOf('function');
-    expect(Routine).toBeDefined();
+    // Skill primitives.
+    expect(Skill).toBeDefined();
+    expect(Skill.make).toBeTypeOf('function');
+    expect(Instructions).toBeDefined();
     expect(Template).toBeDefined();
 
     // Function primitives.
     expect(Process).toBeDefined();
+    expect(Runnable).toBeDefined();
     expect(Trigger).toBeDefined();
     expect(TriggerEvent).toBeDefined();
     expect(Script).toBeDefined();

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

@@ -1,7 +0,0 @@
-{
-  "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 Option from 'effect/Option';\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     * When true, this operation is not serialized into the hypergraph registry.\n     * Use for UI-only operations that should not be discoverable by the AI agent.\n     */\n    readonly skipRegistry?: boolean;\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 * Annotation that marks an operation as idempotent — safe to retry even if a previous execution\n * was interrupted mid-handler. When absent the operation is treated as non-idempotent, and the\n * process runtime will fail (rather than re-run) any handler that was interrupted.\n */\nexport const IdempotentAnnotation = Annotation.make({\n  id: 'org.dxos.operation.idempotent',\n  schema: Schema$.Boolean,\n});\n\n/**\n * Returns true when the operation is explicitly annotated as idempotent.\n */\nexport const isIdempotent = (op: Definition.Any): boolean =>\n  op.meta.annotations\n    ? Option.getOrElse(Annotation.getDictionary(op.meta.annotations, IdempotentAnnotation), () => false)\n    : false;\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", "Option", "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", "IdempotentAnnotation", "schema", "Boolean", "isIdempotent", "getOrElse", "getDictionary", "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/fib-HBDUGQW7.mjs

@@ -1,10 +0,0 @@
-import {
-  fib_default
-} from "./chunk-AFBNVFAY.mjs";
-import "./chunk-JAU4E4EK.mjs";
-import "./chunk-QZS4G6PE.mjs";
-import "./chunk-J5LGTIGS.mjs";
-export {
-  fib_default as default
-};
-//# sourceMappingURL=fib-HBDUGQW7.mjs.map

package/dist/lib/neutral/reply-RJIAJ6FV.mjs

@@ -1,10 +0,0 @@
-import {
-  reply_default
-} from "./chunk-MEPE4HHX.mjs";
-import "./chunk-JAU4E4EK.mjs";
-import "./chunk-QZS4G6PE.mjs";
-import "./chunk-J5LGTIGS.mjs";
-export {
-  reply_default as default
-};
-//# sourceMappingURL=reply-RJIAJ6FV.mjs.map

package/dist/lib/neutral/sleep-3T2CZ7RE.mjs

@@ -1,10 +0,0 @@
-import {
-  sleep_default
-} from "./chunk-2B2KSJT6.mjs";
-import "./chunk-JAU4E4EK.mjs";
-import "./chunk-QZS4G6PE.mjs";
-import "./chunk-J5LGTIGS.mjs";
-export {
-  sleep_default as default
-};
-//# sourceMappingURL=sleep-3T2CZ7RE.mjs.map

package/dist/types/src/Blueprint.d.ts

@@ -1,182 +0,0 @@
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-import { Database, Migration, Obj, Registry, Type, URI } from '@dxos/echo';
-import { BaseError } from '@dxos/errors';
-import * as Operation from './Operation';
-/**
- * Blueprint schema defines the structure for AI assistant blueprints.
- * Blueprints contain instructions, tools, and artifacts that guide the AI's behavior.
- * Blueprints may use tools to create and read artifacts, which are managed by the assistant.
- *
- * The registry `key` and `version` are stored in the object meta — access them via
- * `Obj.getMeta(blueprint).key` and `Obj.getMeta(blueprint).version`.
- */
-export declare const Blueprint: Type.Obj<{
-    readonly name: string;
-    readonly description?: string | undefined;
-    readonly instructions: {
-        readonly source: import("@dxos/echo/internal").Ref<{
-            readonly name?: string | undefined;
-            readonly content: string;
-        } & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
-        readonly inputs?: readonly {
-            readonly name: string;
-            readonly kind: "operation" | "value";
-            readonly default?: any;
-            readonly operation?: string | undefined;
-        }[] | undefined;
-    };
-    readonly tools: readonly (string & import("effect/Brand").Brand<"ToolId">)[];
-    readonly agentCanEnable?: boolean | undefined;
-    readonly mcpServers?: readonly {
-        readonly name?: string | undefined;
-        readonly url: string;
-        readonly protocol: "http" | "sse";
-        readonly apiKey?: string | undefined;
-    }[] | undefined;
-}, Schema.Struct.Fields>;
-/**
- * TypeScript type for Blueprint.
- */
-export type Blueprint = Type.InstanceType<typeof Blueprint>;
-type MakeProps = {
-    key: string;
-    version?: string;
-    name: string;
-} & Partial<Blueprint>;
-/**
- * Create a new Blueprint.
- * The `key` (and optional `version`) are stored in the object meta.
- */
-export declare const make: ({ key, version, tools, instructions, ...props }: MakeProps) => Obj.OfShape<{
-    readonly name: string;
-    readonly description?: string | undefined;
-    readonly instructions: {
-        readonly source: import("@dxos/echo/internal").Ref<{
-            readonly name?: string | undefined;
-            readonly content: string;
-        } & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
-        readonly inputs?: readonly {
-            readonly name: string;
-            readonly kind: "operation" | "value";
-            readonly default?: any;
-            readonly operation?: string | undefined;
-        }[] | undefined;
-    };
-    readonly tools: readonly (string & import("effect/Brand").Brand<"ToolId">)[];
-    readonly agentCanEnable?: boolean | undefined;
-    readonly mcpServers?: readonly {
-        readonly name?: string | undefined;
-        readonly url: string;
-        readonly protocol: "http" | "sse";
-        readonly apiKey?: string | undefined;
-    }[] | undefined;
-} & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object>>;
-/**
- * Get the registry key for a blueprint.
- */
-export declare const getKey: (blueprint: Blueprint) => string;
-/**
- * Get the registry version for a blueprint, if any.
- */
-export declare const getVersion: (blueprint: Blueprint) => string | undefined;
-/**
- * Util to create tool definitions for a blueprint.
- */
-export declare const toolDefinitions: ({ tools, operations, }: {
-    tools?: string[];
-    operations?: Operation.Definition.Any[];
-}) => (string & import("effect/Brand").Brand<"ToolId">)[];
-/**
- * Factory for the blueprints.
- */
-export type Definition = {
-    key: string;
-    make: () => Blueprint;
-};
-/**
- * Returns the canonical URI used to reference this blueprint in the registry.
- * Valid DXN keys produce `dxn:<key>`; other keys use the raw key as a URI.
- * Use this URI with `Ref.fromURI` to bind a blueprint without cloning it to the DB.
- *
- * TODO(wittjosiah): Should use Obj.getURI instead once it supports options to prefer meta key over EID.
- */
-export declare const registryURI: (key: string) => URI.URI;
-/**
- * Resolves a blueprint from the registry by its meta key.
- * Does not check the local database for the blueprint.
- */
-export declare const resolve: (key: string) => Effect.Effect<Blueprint, NotFoundError, Registry.Service>;
-/**
- * Upserts a blueprint into the database.
- * If the blueprint already exists in the database, the local (possibly forked) copy is returned as-is.
- * Otherwise, a fresh copy is cloned from the registry and added.
- * @deprecated Since we're using a registry we no longer need to store blueprints in the database.
- */
-export declare const upsert: (key: string) => Effect.Effect<Blueprint, NotFoundError, Registry.Service | Database.Service>;
-declare const NotFoundError_base: {
-    new (options?: import("@dxos/errors").BaseErrorOptions): {
-        cause?: unknown;
-        stack?: string;
-        name: "BlueprintNotFound";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "BlueprintNotFound";
-    };
-    isError(error: unknown): error is Error;
-    name: "BlueprintNotFound";
-    is(error: unknown): error is BaseError;
-    wrap(options?: Omit<import("@dxos/errors").BaseErrorOptions, 'cause'> & {
-        ifTypeDiffers?: boolean;
-    }): (error: unknown) => {
-        cause?: unknown;
-        stack?: string;
-        name: "BlueprintNotFound";
-        context: Record<string, unknown>;
-        readonly message: string;
-        readonly _tag: "BlueprintNotFound";
-    };
-    extend<Name extends string = string>(name: Name, message?: string): any;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
-    stackTraceLimit: number;
-};
-export declare class NotFoundError extends NotFoundError_base {
-}
-/**
- * Blueprint schema v0.1.0 — `key` is stored as a data property.
- * @deprecated Use {@link Blueprint} (v0.2.0) instead; the `key` and `version` now live in the object meta.
- */
-export declare const Blueprint_v0_1_0: Type.Obj<{
-    readonly key: string;
-    readonly name: string;
-    readonly description?: string | undefined;
-    readonly instructions: {
-        readonly source: import("@dxos/echo/internal").Ref<{
-            readonly name?: string | undefined;
-            readonly content: string;
-        } & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
-        readonly inputs?: readonly {
-            readonly name: string;
-            readonly kind: "operation" | "value";
-            readonly default?: any;
-            readonly operation?: string | undefined;
-        }[] | undefined;
-    };
-    readonly tools: readonly (string & import("effect/Brand").Brand<"ToolId">)[];
-    readonly agentCanEnable?: boolean | undefined;
-    readonly mcpServers?: readonly {
-        readonly name?: string | undefined;
-        readonly url: string;
-        readonly protocol: "http" | "sse";
-        readonly apiKey?: string | undefined;
-    }[] | undefined;
-}, Schema.Struct.Fields>;
-export type Blueprint_v0_1_0 = Type.InstanceType<typeof Blueprint_v0_1_0>;
-/**
- * Schema migrations exported by this module.
- * Exported as an array for extensibility — append future versions here.
- */
-export declare const migrations: Migration.ObjectMigration[];
-export {};
-//# sourceMappingURL=Blueprint.d.ts.map

package/dist/types/src/Blueprint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Blueprint.d.ts","sourceRoot":"","sources":["../../../src/Blueprint.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAAmB,QAAQ,EAAU,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AACpG,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAGzC;;;;;;;GAOG;AAEH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;wBA6CrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,SAAS,CAAC,CAAC;AAE5D,KAAK,SAAS,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;AAEtF;;;GAGG;AACH,eAAO,MAAM,IAAI,oDAA4E,SAAS;;;;;;;;;;;;;;;;;;;;;;;wFAMlG,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,MAAM,cAAe,SAAS,KAAG,MAM7C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,cAAe,SAAS,KAAG,MAAM,GAAG,SAA2C,CAAC;AAEvG;;GAEG;AACH,eAAO,MAAM,eAAe,2BAGzB;IACD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;CACzC,wDAAkH,CAAC;AAEpH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,SAAS,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAS,MAAM,KAAG,GAAG,CAAC,GAA8D,CAAC;AAE7G;;;GAGG;AACH,eAAO,MAAM,OAAO,QAAS,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,aAAa,EAAE,QAAQ,CAAC,OAAO,CAQ1F,CAAC;AAEL;;;;;GAKG;AAEH,eAAO,MAAM,MAAM,QAAS,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,aAAa,EAAE,QAAQ,CAAC,OAAO,GAAG,QAAQ,CAAC,OAAO,CAO5G,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,aAAc,SAAQ,kBAA4D;CAAG;AAMlG;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;wBAsByC,CAAC;AAEvE,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAmB1E;;;GAGG;AACH,eAAO,MAAM,UAAU,6BAAe,CAAC"}

package/dist/types/src/Routine.d.ts

@@ -1,54 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { Obj, Ref, Type } from '@dxos/echo';
-import * as Blueprint from './Blueprint';
-/**
- * Prompt-based operation.
- * May reference blueprints and additional context.
- */
-export declare const Routine: Type.Obj<{
-    readonly name?: string | undefined;
-    readonly description?: string | undefined;
-    readonly input: import("@dxos/echo/internal").JsonSchemaType;
-    readonly output: import("@dxos/echo/internal").JsonSchemaType;
-    readonly instructions: import("@dxos/echo/internal").Ref<{
-        readonly name?: string | undefined;
-        readonly content: string;
-    } & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
-    readonly blueprints: readonly import("@dxos/echo/internal").Ref<{
-        readonly name: string;
-        readonly description?: string | undefined;
-        readonly instructions: {
-            readonly source: import("@dxos/echo/internal").Ref<{
-                readonly name?: string | undefined;
-                readonly content: string;
-            } & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
-            readonly inputs?: readonly {
-                readonly name: string;
-                readonly kind: "operation" | "value";
-                readonly default?: any;
-                readonly operation?: string | undefined;
-            }[] | undefined;
-        };
-        readonly tools: readonly (string & import("effect/Brand").Brand<"ToolId">)[];
-        readonly agentCanEnable?: boolean | undefined;
-        readonly mcpServers?: readonly {
-            readonly name?: string | undefined;
-            readonly url: string;
-            readonly protocol: "http" | "sse";
-            readonly apiKey?: string | undefined;
-        }[] | undefined;
-    } & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
-    readonly context: readonly any[];
-}, Schema.Struct.Fields>;
-export type Routine = Type.InstanceType<typeof Routine>;
-export type MakeProps = {
-    name?: string;
-    description?: string;
-    input?: Schema.Schema.AnyNoContext;
-    output?: Schema.Schema.AnyNoContext;
-    instructions?: string;
-    blueprints?: Ref.Ref<Blueprint.Blueprint>[];
-    context?: any[];
-};
-export declare const make: ({ name, description, input, output, instructions, blueprints, context, }: MakeProps) => Routine;
-//# sourceMappingURL=Routine.d.ts.map

package/dist/types/src/Routine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Routine.d.ts","sourceRoot":"","sources":["../../../src/Routine.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAA+B,GAAG,EAAE,GAAG,EAAE,IAAI,EAAU,MAAM,YAAY,CAAC;AAGjF,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC;;;GAGG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAmBnB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,OAAO,CAAC,CAAC;AAExD,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;IAC5C,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,IAAI,6EAQd,SAAS,KAAG,OASX,CAAC"}