@artinet/sdk 0.5.5 → 0.5.6

package/dist/types/types/interfaces/services/core/context/context.d.ts

@@ -0,0 +1,208 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @fileoverview Core Context Interface Definition
+ *
+ * This module defines the CoreContext interface, which serves as the central
+ * execution environment for all command processing. The context encapsulates
+ * the command, state management, event handling, and cancellation mechanisms
+ * required for execution engine operations.
+ *
+ * @module CoreContext
+ * @version 1.0.0
+ * @since 0.5.6
+ * @author The Artinet Project
+ */
+import { EventManagerInterface } from "../managers/event.js";
+import { CoreCommand, CoreState, CoreUpdate } from "./types.js";
+import { ReceiveCommandProxyInterface } from "./command.js";
+/**
+ * Core execution context interface that provide the complete environment for command execution.
+ *
+ * The CoreContext serves as the primary execution environment passed to execution engines.
+ * It encapsulates all the necessary components for command processing, including the command
+ * itself, state management, event handling, and cancellation signals. This design enables
+ * execution engines to be stateless functions that receive everything they need through
+ * the context parameter.
+ *
+ * The context is designed to support "Context Engineering" - the practice of carefully
+ * constructing execution environments that contain all necessary information and capabilities
+ * for effective command processing. As the system evolves, the context becomes increasingly
+ * important for enabling sophisticated execution patterns.
+ *
+ * @template TCommand - The command type, must extend CoreCommand
+ * @template TState - The state type, must extend CoreState
+ * @template TUpdate - The update type, must extend CoreUpdate
+ *
+ * @example
+ * ```typescript
+ * // Using context in an execution engine
+ * const myEngine: ExecutionEngine<MyCommand, MyState, MyUpdate> = async function* (context) {
+ *   const { command, State, events, signal, isCancelled } = context;
+ *
+ *   // Get current state
+ *   const currentState = State();
+ *
+ *   // Check for cancellation
+ *   if (isCancelled() || signal.aborted) {
+ *     yield { type: 'cancelled' };
+ *     return;
+ *   }
+ *
+ *   // Process command
+ *   const result = await processCommand(command);
+ *
+ *   // Emit events and yield updates
+ *   events.emit('progress', { progress: 0.5 });
+ *   yield { type: 'progress', progress: 0.5, data: result };
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Creating and using a context
+ * const context: CoreContext<MyCommand, MyState, MyUpdate> = {
+ *   contextId: 'execution-123',
+ *   command: createCommandProxy(myCommand),
+ *   events: createEventManager(),
+ *   signal: abortController.signal,
+ *   isCancelled: () => abortController.signal.aborted,
+ *   State: () => getCurrentState()
+ * };
+ *
+ * // Execute with context
+ * for await (const update of myEngine(context)) {
+ *   console.log('Update:', update);
+ * }
+ * ```
+ *
+ * @remarks
+ * **Design Philosophy:**
+ * The context represents a shift toward functional execution patterns where execution
+ * engines are pure functions that receive all necessary dependencies through the
+ * context parameter. This approach enables:
+ *
+ * - **Testability**: Easy to mock and test individual components
+ * - **Composability**: Different engines can work with the same context interface
+ * - **Flexibility**: Context can be enhanced without changing engine signatures
+ * - **Debugging**: Complete execution environment is visible and traceable
+ *
+ * **Context Engineering:**
+ * As mentioned in the original note, Context Engineering is becoming increasingly
+ * important. This involves carefully designing contexts that provide the right
+ * level of abstraction and capability for specific execution scenarios.
+ *
+ * @public
+ * @since 0.5.6
+ */
+export interface CoreContext<TCommand extends CoreCommand = CoreCommand, TState extends CoreState = CoreState, TUpdate extends CoreUpdate = CoreUpdate> {
+    /**
+     * Unique identifier for this execution context.
+     *
+     * This ID is used throughout the system to track and correlate execution
+     * activities, logs, and state updates with specific command executions.
+     *
+     * @example
+     * ```typescript
+     * console.log(`Starting execution: ${context.contextId}`);
+     * loggerService.info(`[${context.contextId}] Processing command`);
+     * ```
+     */
+    readonly contextId: string;
+    /**
+     * Command proxy interface providing access to the command being executed.
+     *
+     * The command proxy wraps the original command and may provide additional
+     * functionality such as validation, logging, or transformation. It allows
+     * execution engines to access command data in a controlled manner.
+     *
+     * @example
+     * ```typescript
+     * const { command } = context;
+     *
+     * // Access command properties
+     * const userId = command.metadata?.userId;
+     * const taskType = command.type;
+     * const parameters = command.params;
+     *
+     * // Use command data in processing
+     * const result = await processTask(taskType, parameters, userId);
+     * ```
+     */
+    command: ReceiveCommandProxyInterface<TCommand>;
+    /**
+     * Function to check if the execution has been cancelled.
+     *
+     * This function provides a convenient way to check cancellation status
+     * throughout execution. It may aggregate multiple cancellation sources
+     * including abort signals, service-level cancellation, and timeout conditions.
+     *
+     * @returns True if the execution should be cancelled, false otherwise
+     *
+     * @example
+     * ```typescript
+     * // Check before expensive operations
+     * if (context.isCancelled()) {
+     *   yield { type: 'cancelled', reason: 'User cancellation' };
+     *   return;
+     * }
+     *
+     * // Check in processing loops
+     * for (const item of largeDataSet) {
+     *   if (context.isCancelled()) break;
+     *   await processItem(item);
+     * }
+     * ```
+     */
+    readonly isCancelled: () => boolean;
+    /**
+     * Abort signal for cancellation handling.
+     *
+     * This standard AbortSignal provides a way to handle cancellation in a
+     * platform-standard manner. It can be passed to fetch requests, timeouts,
+     * and other async operations that support cancellation.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Event manager for handling execution lifecycle events.
+     *
+     * The event manager provides event emission and subscription capabilities
+     * for execution lifecycle events. It handles state transitions, error
+     * scenarios, and completion notifications.
+     *
+     * @example
+     * ```typescript
+     * const { events } = context;
+     *
+     * // Listen for events
+     * events.on('update', (state, update) => {
+     *   console.log('State updated:', state);
+     * });
+     *
+     * // Handle errors
+     * events.on('error', (error, state) => {
+     *   console.error('Execution error:', error);
+     * });
+     * ```
+     */
+    readonly events: EventManagerInterface<TCommand, TState, TUpdate>;
+    /**
+     * Function to get the current execution state.
+     *
+     * This function provides access to the current state of the execution.
+     * The state represents the accumulated result of all updates processed
+     * so far and serves as the foundation for decision-making in execution engines.
+     *
+     * @returns The current execution state
+     *
+     * @example
+     * ```typescript
+     * // Get current state for decision making
+     * const currentState = context.State();
+     * ```
+     */
+    readonly State: () => TState;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/types/types/interfaces/services/core/context/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/context/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,MAAM,WAAW,WAAW,CAC1B,QAAQ,SAAS,WAAW,GAAG,WAAW,EAC1C,MAAM,SAAS,SAAS,GAAG,SAAS,EACpC,OAAO,SAAS,UAAU,GAAG,UAAU;IAEvC;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,EAAE,4BAA4B,CAAC,QAAQ,CAAC,CAAC;IAEhD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC;IAEpC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAE7B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAElE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,CAAC;CAC9B"}

package/dist/types/types/interfaces/services/core/context/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./command.js";
+export * from "./context.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/types/interfaces/services/core/context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/context/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/dist/types/types/interfaces/services/core/context/types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * We're starting with simple base types for the core context.
+ * The base types will expand as we determine what is common across all services.
+ */
+export type CoreCommand<TCommand extends object = object> = TCommand;
+export type CoreState<TState extends {} = {}> = TState;
+export type CoreUpdate<TUpdate = unknown> = TUpdate;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/types/interfaces/services/core/context/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/context/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AAEH,MAAM,MAAM,WAAW,CAAC,QAAQ,SAAS,MAAM,GAAG,MAAM,IAAI,QAAQ,CAAC;AAErE,MAAM,MAAM,SAAS,CAAC,MAAM,SAAS,EAAE,GAAG,EAAE,IAAI,MAAM,CAAC;AAEvD,MAAM,MAAM,UAAU,CAAC,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC"}

package/dist/types/types/interfaces/services/core/execution/engine.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @fileoverview Core Execution Engine Type Definition
+ *
+ * This module defines the fundamental execution engine type that serves as the
+ * foundation for all command processing in the core service framework. Execution
+ * engines are responsible for transforming commands into streams of updates.
+ *
+ * @module CoreExecutionEngine
+ * @version 1.0.0
+ * @since 0.5.6
+ * @author The Artinet Project
+ */
+import { CoreCommand, CoreContext, CoreState, CoreUpdate } from "../context/index.js";
+/**
+ * Core execution engine function signature.
+ *
+ * An ExecutionEngine is a function that accepts a CoreContext and returns an
+ * AsyncGenerator yielding updates. This pattern enables streaming execution
+ * where commands can produce multiple updates over time, supporting both
+ * real-time processing and long-running operations.
+ *
+ * The engine receives a complete execution context containing the command to
+ * execute, current state, event management, and cancellation signals. It
+ * processes the command and yields updates as execution progresses, allowing
+ * consumers to receive real-time feedback about execution status.
+ *
+ * @template TCommand - The command type, must extend CoreCommand
+ * @template TState - The state type, must extend CoreState
+ * @template TUpdate - The update type, must extend CoreUpdate
+ *
+ * @param context - The execution context containing command, state, and environment
+ * @returns AsyncGenerator that yields updates during execution
+ *
+ * @example
+ * ```typescript
+ * // Simple execution engine that processes a command
+ * const simpleEngine: ExecutionEngine<MyCommand, MyState, MyUpdate> = async function* (context) {
+ *   const { command, State } = context;
+ *
+ *   // Yield progress update
+ *   yield {
+ *     type: 'progress',
+ *     message: 'Starting execution...',
+ *     progress: 0
+ *   };
+ *
+ *   // Process command
+ *   const result = await processCommand(command);
+ *
+ *   // Yield intermediate results
+ *   yield {
+ *     type: 'data',
+ *     data: result.intermediateData,
+ *     progress: 0.5
+ *   };
+ *
+ *   // Complete processing
+ *   const finalResult = await finalizeResult(result);
+ *
+ *   // Yield final update
+ *   yield {
+ *     type: 'complete',
+ *     data: finalResult,
+ *     progress: 1.0
+ *   };
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Execution engine with error handling and cancellation
+ * const robustEngine: ExecutionEngine = async function* (context) {
+ *   const { command, signal, isCancelled } = context;
+ *
+ *   try {
+ *     for (let i = 0; i < command.steps.length; i++) {
+ *       // Check for cancellation
+ *       if (isCancelled() || signal.aborted) {
+ *         yield { type: 'cancelled', step: i };
+ *         return;
+ *       }
+ *
+ *       // Process step
+ *       const stepResult = await processStep(command.steps[i]);
+ *
+ *       yield {
+ *         type: 'step-complete',
+ *         step: i,
+ *         result: stepResult,
+ *         progress: (i + 1) / command.steps.length
+ *       };
+ *     }
+ *   } catch (error) {
+ *     yield { type: 'error', error: error.message };
+ *   }
+ * };
+ * ```
+ *
+ * @public
+ * @since 0.5.6
+ */
+export type ExecutionEngine<TCommand extends CoreCommand = CoreCommand, TState extends CoreState = CoreState, TUpdate extends CoreUpdate = CoreUpdate> = (context: CoreContext<TCommand, TState, TUpdate>) => AsyncGenerator<TUpdate, void, unknown>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/types/types/interfaces/services/core/execution/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/execution/engine.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,WAAW,EACX,WAAW,EACX,SAAS,EACT,UAAU,EACX,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,MAAM,MAAM,eAAe,CACzB,QAAQ,SAAS,WAAW,GAAG,WAAW,EAC1C,MAAM,SAAS,SAAS,GAAG,SAAS,EACpC,OAAO,SAAS,UAAU,GAAG,UAAU,IACrC,CACF,OAAO,EAAE,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,KAC5C,cAAc,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC"}

package/dist/types/types/interfaces/services/core/execution/environment.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CoreCommand, CoreState, CoreUpdate } from "../context/index.js";
+import { ServiceInterface } from "../service.js";
+import { ExecutionEngine } from "./engine.js";
+export interface ExecutionEnvironment<TCommand extends CoreCommand = CoreCommand, TState extends CoreState = CoreState, TUpdate extends CoreUpdate = CoreUpdate> {
+    service: ServiceInterface<TCommand, TState, TUpdate>;
+    engine?: ExecutionEngine<TCommand, TState, TUpdate>;
+}
+//# sourceMappingURL=environment.d.ts.map

package/dist/types/types/interfaces/services/core/execution/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/execution/environment.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,WAAW,oBAAoB,CACnC,QAAQ,SAAS,WAAW,GAAG,WAAW,EAC1C,MAAM,SAAS,SAAS,GAAG,SAAS,EACpC,OAAO,SAAS,UAAU,GAAG,UAAU;IAEvC,OAAO,EAAE,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACrD,MAAM,CAAC,EAAE,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;CACrD"}

package/dist/types/types/interfaces/services/core/execution/execute.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CoreContext, CoreCommand, CoreState, CoreUpdate } from "../context/index.js";
+import { ExecutionEngine } from "./engine.js";
+export type ExecuteFunction<TCommand extends CoreCommand = CoreCommand, TState extends CoreState = CoreState, TUpdate extends CoreUpdate = CoreUpdate> = (engine: ExecutionEngine<TCommand, TState, TUpdate>, context: CoreContext<TCommand, TState, TUpdate>) => Promise<void>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/types/types/interfaces/services/core/execution/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/execution/execute.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,WAAW,EACX,WAAW,EACX,SAAS,EACT,UAAU,EACX,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,MAAM,eAAe,CACzB,QAAQ,SAAS,WAAW,GAAG,WAAW,EAC1C,MAAM,SAAS,SAAS,GAAG,SAAS,EACpC,OAAO,SAAS,UAAU,GAAG,UAAU,IACrC,CACF,MAAM,EAAE,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAClD,OAAO,EAAE,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,KAC5C,OAAO,CAAC,IAAI,CAAC,CAAC"}

package/dist/types/types/interfaces/services/core/execution/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./engine.js";
+export * from "./environment.js";
+export * from "./execute.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/types/interfaces/services/core/execution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/execution/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC"}

package/dist/types/types/interfaces/services/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./context/index.js";
+export * from "./execution/index.js";
+export * from "./managers/index.js";
+export * from "./service.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/types/interfaces/services/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/types/interfaces/services/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC"}

package/dist/types/types/interfaces/services/core/managers/cancellation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface CancellationManagerInterface {
+    addCancellation(id: string): void;
+    removeCancellation(id: string): void;
+    isCancelled(id: string): boolean;
+}
+//# sourceMappingURL=cancellation.d.ts.map

package/dist/types/types/interfaces/services/core/managers/cancellation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancellation.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/managers/cancellation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,4BAA4B;IAC3C,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC"}

package/dist/types/types/interfaces/services/core/managers/connection.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface ConnectionManagerInterface {
+    addConnection(id: string): void;
+    removeConnection(id: string): void;
+    isConnected(id: string): boolean;
+}
+//# sourceMappingURL=connection.d.ts.map

package/dist/types/types/interfaces/services/core/managers/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/managers/connection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,0BAA0B;IACzC,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;CAClC"}

package/dist/types/types/interfaces/services/core/managers/context.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CoreCommand, CoreState, CoreContext, CoreUpdate } from "../context/index.js";
+/**
+ * @description The context manager interface.
+ * @type {ContextManagerInterface<TCommand, TState>}
+ * @note This will become an increasingly important part of the system as Context Engineering becomes more important.
+ * currently it is used to store & retrieve contexts from storage but greater degrees of control may be needed.
+ * ex. forking/merging contexts, forwarding contexts to other services, nesting contexts, etc.
+ */
+export interface ContextManagerInterface<TCommand extends CoreCommand = CoreCommand, TState extends CoreState = CoreState, TUpdate extends CoreUpdate = CoreUpdate> {
+    getContext: (id: string) => CoreContext<TCommand, TState, TUpdate> | undefined;
+    setContext: (id: string, context: CoreContext<TCommand, TState, TUpdate>) => void;
+    deleteContext: (id: string) => void;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/types/types/interfaces/services/core/managers/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../../../../src/types/interfaces/services/core/managers/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,WAAW,EACX,SAAS,EACT,WAAW,EACX,UAAU,EACX,MAAM,qBAAqB,CAAC;AAE7B;;;;;;GAMG;AACH,MAAM,WAAW,uBAAuB,CACtC,QAAQ,SAAS,WAAW,GAAG,WAAW,EAC1C,MAAM,SAAS,SAAS,GAAG,SAAS,EACpC,OAAO,SAAS,UAAU,GAAG,UAAU;IAEvC,UAAU,EAAE,CACV,EAAE,EAAE,MAAM,KACP,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IACxD,UAAU,EAAE,CACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,KAC5C,IAAI,CAAC;IACV,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC"}