@jupyter/chat 0.23.0-alpha.2 → 0.23.0-alpha.3

package/lib/__tests__/input-model.spec.d.ts

@@ -0,0 +1,9 @@
+declare module '../types' {
+    interface IMessageMetadata {
+        persona?: string;
+        model?: {
+            id: string;
+        };
+    }
+}
+export {};

package/lib/__tests__/input-model.spec.js

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) Jupyter Development Team.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { InputModel } from '../input-model';
+describe('test input model', () => {
+    describe('metadata', () => {
+        it('should start with empty metadata', () => {
+            const model = new InputModel({ onSend: jest.fn() });
+            expect(model.getMetadata()).toEqual({});
+        });
+        it('should seed metadata from options', () => {
+            const model = new InputModel({
+                onSend: jest.fn(),
+                metadata: { persona: 'kiro' }
+            });
+            expect(model.getMetadata()).toEqual({ persona: 'kiro' });
+        });
+        it('should merge patches with updateMetadata', () => {
+            const model = new InputModel({ onSend: jest.fn() });
+            model.updateMetadata({ persona: 'kiro' });
+            model.updateMetadata({ model: { id: 'claude-opus-48' } });
+            expect(model.getMetadata()).toEqual({
+                persona: 'kiro',
+                model: { id: 'claude-opus-48' }
+            });
+        });
+        it('should overwrite existing keys on update', () => {
+            const model = new InputModel({ onSend: jest.fn() });
+            model.updateMetadata({ persona: 'kiro' });
+            model.updateMetadata({ persona: 'jupyternaut' });
+            expect(model.getMetadata()).toEqual({ persona: 'jupyternaut' });
+        });
+        it('should shallow-merge: a top-level key replaces the whole value', () => {
+            const model = new InputModel({ onSend: jest.fn() });
+            model.updateMetadata({ model: { id: 'a' } });
+            // Passing `model` again replaces it wholesale (no recursive merge).
+            model.updateMetadata({ model: { id: 'b' } });
+            expect(model.getMetadata()).toEqual({ model: { id: 'b' } });
+        });
+        it('should not be mutated by later changes to a patch', () => {
+            const model = new InputModel({ onSend: jest.fn() });
+            const patch = { model: { id: 'a' } };
+            model.updateMetadata(patch);
+            // Mutating the patch after the fact must not reach into stored metadata.
+            patch.model.id = 'tampered';
+            expect(model.getMetadata()).toEqual({ model: { id: 'a' } });
+        });
+        it('should clear metadata', () => {
+            const model = new InputModel({ onSend: jest.fn() });
+            model.updateMetadata({ persona: 'kiro' });
+            model.clearMetadata();
+            expect(model.getMetadata()).toEqual({});
+        });
+        it('should emit metadataChanged on update and clear', () => {
+            var _a;
+            const model = new InputModel({ onSend: jest.fn() });
+            const emitted = [];
+            (_a = model.metadataChanged) === null || _a === void 0 ? void 0 : _a.connect((_, metadata) => {
+                emitted.push({ ...metadata });
+            });
+            model.updateMetadata({ persona: 'kiro' });
+            model.clearMetadata();
+            expect(emitted).toEqual([{ persona: 'kiro' }, {}]);
+        });
+    });
+    describe('send', () => {
+        it('should attach metadata to the message when non-empty', () => {
+            const onSend = jest.fn();
+            const model = new InputModel({ onSend });
+            model.updateMetadata({ persona: 'kiro' });
+            model.send('hello');
+            const message = onSend.mock.calls[0][0];
+            expect(message.body).toBe('hello');
+            expect(message.metadata).toEqual({ persona: 'kiro' });
+        });
+        it('should omit metadata from the message when empty', () => {
+            const onSend = jest.fn();
+            const model = new InputModel({ onSend });
+            model.send('hello');
+            const message = onSend.mock.calls[0][0];
+            expect(message.metadata).toBeUndefined();
+        });
+        it('should send a copy of the metadata', () => {
+            const onSend = jest.fn();
+            const model = new InputModel({ onSend });
+            model.updateMetadata({ persona: 'kiro' });
+            model.send('hello');
+            const message = onSend.mock.calls[0][0];
+            model.updateMetadata({ persona: 'jupyternaut' });
+            expect(message.metadata).toEqual({ persona: 'kiro' });
+        });
+        it('should keep metadata after sending (sticky selection)', () => {
+            // Unlike attachments/mentions, metadata carries the picker's
+            // persona/model/settings selection, which is sticky across messages.
+            const model = new InputModel({ onSend: jest.fn() });
+            model.updateMetadata({ persona: 'kiro' });
+            model.send('hello');
+            expect(model.getMetadata()).toEqual({ persona: 'kiro' });
+        });
+    });
+});

package/lib/__tests__/multichat-panel.spec.js

@@ -3,9 +3,11 @@
  * Distributed under the terms of the Modified BSD License.
  */
 import { RenderMimeRegistry } from '@jupyterlab/rendermime';
+import { ObservableList } from '@jupyterlab/observables';
 import { Widget } from '@lumino/widgets';
 import { MultiChatPanel } from '../widgets/multichat-panel';
 import { defaultPlaceholder } from '../widgets/placeholder';
+import { MockChatModel } from './mocks';
 describe('MultiChatPanel', () => {
     let rmRegistry;
     beforeEach(() => {
@@ -56,31 +58,6 @@ describe('MultiChatPanel', () => {
             panel.dispose();
         });
     });
-    describe('openInMain', () => {
-        it('should not dispose the model when moving to main area', async () => {
-            const { MockChatModel } = await import('./mocks');
-            const model = new MockChatModel();
-            const openInMain = jest.fn().mockResolvedValue(true);
-            const panel = new MultiChatPanel({ rmRegistry, openInMain });
-            panel.open({ model, displayName: 'test-chat' });
-            // Find the 'moveMain' toolbar button by name and invoke its click handler directly.
-            // ToolbarButton stores the onClick handler independently of DOM/React rendering,
-            // so this works without attaching the widget to the document.
-            const toolbar = panel.current.toolbar;
-            const names = Array.from(toolbar.names());
-            const moveMainIdx = names.indexOf('moveMain');
-            expect(moveMainIdx).toBeGreaterThan(-1);
-            const moveButton = toolbar.layout.widgets[moveMainIdx];
-            moveButton.onClick();
-            // Wait for the async onClick handler: openInMain resolves, then onClose is called.
-            await Promise.resolve();
-            expect(openInMain).toHaveBeenCalledWith(model.name);
-            expect(model.isDisposed).toBe(false);
-            expect(panel.getLoadedModel('test-chat')).toBeUndefined();
-            model.dispose();
-            panel.dispose();
-        });
-    });
     describe('placeholderFactory', () => {
         it('should use defaultPlaceholder when no factory is provided', () => {
             const panel = new MultiChatPanel({ rmRegistry });
@@ -164,7 +141,7 @@ describe('MultiChatPanel', () => {
             expect(props.onCreate).toBeDefined();
             panel.dispose();
         });
-        it('should call factory.create again when the placeholder is re-added after closing a chat', async () => {
+        it('should call factory.create again when the placeholder is re-added after closing a chat', () => {
             const factory = {
                 create: jest.fn().mockReturnValue(new Widget())
             };
@@ -175,7 +152,6 @@ describe('MultiChatPanel', () => {
                 createModel
             });
             // Simulate opening and closing a chat to trigger _addPlaceholder again.
-            const { MockChatModel } = await import('./mocks');
             const model = new MockChatModel();
             panel.open({ model, displayName: 'test-chat' });
             panel.unsetLoadedModel('test-chat');
@@ -194,4 +170,79 @@ describe('MultiChatPanel', () => {
             panel.dispose();
         });
     });
+    describe('chatToolbarFactory', () => {
+        const makeFactory = (items) => jest.fn().mockReturnValue(new ObservableList({ values: items }));
+        it('should call factory with the panel when a chat is opened', () => {
+            const factory = makeFactory([{ name: 'myButton', widget: new Widget() }]);
+            const panel = new MultiChatPanel({
+                rmRegistry,
+                chatToolbarFactory: factory
+            });
+            const model = new MockChatModel();
+            const chatWidget = panel.open({ model, displayName: 'test' });
+            expect(factory).toHaveBeenCalledTimes(1);
+            expect(factory.mock.calls[0][0].widget).toBe(chatWidget);
+            panel.dispose();
+        });
+        it('should add the created widget to the chat toolbar', () => {
+            const panel = new MultiChatPanel({
+                rmRegistry,
+                chatToolbarFactory: makeFactory([
+                    { name: 'myButton', widget: new Widget() }
+                ])
+            });
+            const model = new MockChatModel();
+            panel.open({ model, displayName: 'test' });
+            const toolbar = panel.current.toolbar;
+            expect(Array.from(toolbar.names())).toContain('myButton');
+            panel.dispose();
+        });
+        it('should insert the item before "close"', () => {
+            const panel = new MultiChatPanel({
+                rmRegistry,
+                chatToolbarFactory: makeFactory([
+                    { name: 'myButton', widget: new Widget() }
+                ])
+            });
+            const model = new MockChatModel();
+            panel.open({ model, displayName: 'test' });
+            const toolbar = panel.current.toolbar;
+            const names = Array.from(toolbar.names());
+            expect(names.indexOf('myButton')).toBeLessThan(names.indexOf('close'));
+            panel.dispose();
+        });
+        it('should add all items when factory returns multiple items', () => {
+            const panel = new MultiChatPanel({
+                rmRegistry,
+                chatToolbarFactory: makeFactory([
+                    { name: 'item1', widget: new Widget() },
+                    { name: 'item2', widget: new Widget() }
+                ])
+            });
+            const model = new MockChatModel();
+            panel.open({ model, displayName: 'test' });
+            const toolbar = panel.current.toolbar;
+            const names = Array.from(toolbar.names());
+            expect(names).toContain('item1');
+            expect(names).toContain('item2');
+            panel.dispose();
+        });
+        it('should call factory again for each newly opened chat', () => {
+            const factory = jest.fn().mockImplementation(() => new ObservableList({
+                values: [{ name: 'myButton', widget: new Widget() }]
+            }));
+            const panel = new MultiChatPanel({
+                rmRegistry,
+                chatToolbarFactory: factory
+            });
+            const model1 = new MockChatModel();
+            panel.open({ model: model1, displayName: 'chat1' });
+            panel.unsetLoadedModel('chat1');
+            const model2 = new MockChatModel();
+            panel.open({ model: model2, displayName: 'chat2' });
+            expect(factory).toHaveBeenCalledTimes(2);
+            expect(factory.mock.results[0].value).not.toBe(factory.mock.results[1].value);
+            panel.dispose();
+        });
+    });
 });

package/lib/components/messages/message.js

@@ -70,7 +70,7 @@ export function ChatMessageBase(props) {
         });
         const inputModel = new InputModel({
             chatContext: model.createChatContext(),
-            onSend: (input, model) => updateMessage(message.id, input, model),
+            onSend: (newMessage) => updateMessage(message.id, newMessage),
             onCancel: () => cancelEdition(),
             value: body,
             activeCellManager: model.activeCellManager,
@@ -92,18 +92,25 @@ export function ChatMessageBase(props) {
         setEdit(false);
     }, [model, message]);
     // Update the content of the message.
-    const updateMessage = useCallback((id, input, inputModel) => {
-        var _a;
-        if (!canEdit || !inputModel) {
+    const updateMessage = useCallback((id, newMessage) => {
+        const inputModel = model.getEditionModel(id);
+        if (!canEdit || !inputModel || !model.updateMessage) {
+            setEdit(false);
             return;
         }
         // Update the message
         const updatedMessage = { ...message };
-        updatedMessage.body = input;
-        updatedMessage.attachments = inputModel.attachments;
-        updatedMessage.mentions = inputModel.mentions;
+        if (newMessage.body) {
+            updatedMessage.body = newMessage.body;
+        }
+        if (newMessage.attachments) {
+            updatedMessage.attachments = newMessage.attachments;
+        }
+        if (newMessage.mentions) {
+            updatedMessage.mentions = newMessage.mentions;
+        }
         model.updateMessage(id, updatedMessage);
-        (_a = model.getEditionModel(message.id)) === null || _a === void 0 ? void 0 : _a.dispose();
+        inputModel.dispose();
         setEdit(false);
     }, [model, message, canEdit]);
     // Delete the message.

package/lib/index.d.ts

@@ -8,4 +8,5 @@ export * from './registers';
 export * from './selection-watcher';
 export * from './tokens';
 export * from './types';
+export * from './utils';
 export * from './widgets';

package/lib/index.js

@@ -12,4 +12,5 @@ export * from './registers';
 export * from './selection-watcher';
 export * from './tokens';
 export * from './types';
+export * from './utils';
 export * from './widgets';

package/lib/input-model.d.ts

@@ -4,7 +4,7 @@ import { ISignal } from '@lumino/signaling';
 import { IActiveCellManager } from './active-cell-manager';
 import { ISelectionWatcher } from './selection-watcher';
 import { IChatContext } from './model';
-import { IAttachment, IUser } from './types';
+import { IAttachment, IMessageMetadata, INewMessage, IUser } from './types';
 /**
  * The chat input interface.
  */
@@ -118,6 +118,27 @@ export interface IInputModel extends IDisposable {
      * Clear mentions list.
      */
     clearMentions(): void;
+    /**
+     * Get the metadata to attach to the next message to send.
+     */
+    getMetadata(): IMessageMetadata;
+    /**
+     * Merge a patch into the metadata to attach to the next message to send.
+     *
+     * This is a *shallow* merge: each key in `patch` replaces the existing value
+     * at that key wholesale, rather than being merged recursively. To change a
+     * nested field, pass the whole new value for its top-level key. The patch is
+     * deep-copied, so mutating it afterwards won't affect the stored metadata.
+     */
+    updateMetadata(patch: IMessageMetadata): void;
+    /**
+     * Clear the metadata.
+     */
+    clearMetadata(): void;
+    /**
+     * A signal emitting when the metadata has changed.
+     */
+    readonly metadataChanged?: ISignal<IInputModel, IMessageMetadata>;
     /**
      * A signal emitting when disposing of the model.
      */
@@ -240,6 +261,27 @@ export declare class InputModel implements IInputModel {
      * Clear mentions list.
      */
     clearMentions: () => void;
+    /**
+     * Get the metadata to attach to the next message to send.
+     */
+    getMetadata(): IMessageMetadata;
+    /**
+     * Merge a patch into the metadata to attach to the next message to send.
+     *
+     * This is a *shallow* merge: each key in `patch` replaces the existing value
+     * at that key wholesale, rather than being merged recursively. To change a
+     * nested field, pass the whole new value for its top-level key. The patch is
+     * deep-copied, so mutating it afterwards won't affect the stored metadata.
+     */
+    updateMetadata: (patch: IMessageMetadata) => void;
+    /**
+     * Clear the metadata.
+     */
+    clearMetadata: () => void;
+    /**
+     * A signal emitting when the metadata has changed.
+     */
+    get metadataChanged(): ISignal<IInputModel, IMessageMetadata>;
     /**
      * Dispose the input model.
      */
@@ -260,6 +302,7 @@ export declare class InputModel implements IInputModel {
     private _currentWord;
     private _attachments;
     private _mentions;
+    private _metadata;
     private _activeCellManager;
     private _selectionWatcher;
     private _documentManager;
@@ -270,6 +313,7 @@ export declare class InputModel implements IInputModel {
     private _configChanged;
     private _focusInputSignal;
     private _attachmentsChanged;
+    private _metadataChanged;
     private _onDisposed;
     private _isDisposed;
 }
@@ -284,7 +328,7 @@ export declare namespace InputModel {
          * @param content - the content of the message.
          * @param model - the model of the input sending the message.
          */
-        onSend: (content: string, model?: InputModel) => void;
+        onSend: (message: INewMessage) => void;
         /**
          * Function that should cancel the message edition.
          */
@@ -301,6 +345,10 @@ export declare namespace InputModel {
          * The initial mentions.
          */
         mentions?: IUser[];
+        /**
+         * The initial metadata.
+         */
+        metadata?: IMessageMetadata;
         /**
          * The current cursor index.
          * This refers to the index of the character in front of the cursor.

package/lib/input-model.js

@@ -14,8 +14,27 @@ export class InputModel {
          * Function to send a message.
          */
         this.send = (input) => {
-            this._onSend(input, this);
+            const message = {
+                body: input
+            };
+            // Add the attachments
+            if (this.attachments.length) {
+                message.attachments = [...this.attachments];
+            }
+            // Add the mentions
+            if (this.mentions.length) {
+                message.mentions = [...this.mentions];
+            }
+            // Add the metadata
+            if (Object.keys(this._metadata).length) {
+                message.metadata = { ...this._metadata };
+            }
+            // Send the message
+            this._onSend(message);
+            // Clear the input
             this.value = '';
+            this.clearAttachments();
+            this.clearMentions();
         };
         /**
          * Add attachment to send with next message.
@@ -75,6 +94,29 @@ export class InputModel {
         this.clearMentions = () => {
             this._mentions = [];
         };
+        /**
+         * Merge a patch into the metadata to attach to the next message to send.
+         *
+         * This is a *shallow* merge: each key in `patch` replaces the existing value
+         * at that key wholesale, rather than being merged recursively. To change a
+         * nested field, pass the whole new value for its top-level key. The patch is
+         * deep-copied, so mutating it afterwards won't affect the stored metadata.
+         */
+        this.updateMetadata = (patch) => {
+            // Deep-copy the patch so a caller mutating a nested field afterwards can't
+            // reach into the stored metadata. `this._metadata` only ever holds values
+            // that were themselves deep-copied on the way in, so a shallow spread of it
+            // is safe.
+            this._metadata = { ...this._metadata, ...structuredClone(patch) };
+            this._metadataChanged.emit(this._metadata);
+        };
+        /**
+         * Clear the metadata.
+         */
+        this.clearMetadata = () => {
+            this._metadata = {};
+            this._metadataChanged.emit(this._metadata);
+        };
         this._cursorIndex = null;
         this._currentWord = null;
         this._valueChanged = new Signal(this);
@@ -83,6 +125,7 @@ export class InputModel {
         this._configChanged = new Signal(this);
         this._focusInputSignal = new Signal(this);
         this._attachmentsChanged = new Signal(this);
+        this._metadataChanged = new Signal(this);
         this._onDisposed = new Signal(this);
         this._isDisposed = false;
         this._id = (_a = options.id) !== null && _a !== void 0 ? _a : `input-${UUID.uuid4()}`;
@@ -91,6 +134,7 @@ export class InputModel {
         this._value = options.value || '';
         this._attachments = options.attachments || [];
         this._mentions = options.mentions || [];
+        this._metadata = options.metadata || {};
         this.cursorIndex = options.cursorIndex || this.value.length;
         this._activeCellManager = (_b = options.activeCellManager) !== null && _b !== void 0 ? _b : null;
         this._selectionWatcher = (_c = options.selectionWatcher) !== null && _c !== void 0 ? _c : null;
@@ -262,6 +306,18 @@ export class InputModel {
             this._mentions.splice(index, 1);
         }
     }
+    /**
+     * Get the metadata to attach to the next message to send.
+     */
+    getMetadata() {
+        return this._metadata;
+    }
+    /**
+     * A signal emitting when the metadata has changed.
+     */
+    get metadataChanged() {
+        return this._metadataChanged;
+    }
     /**
      * Dispose the input model.
      */

package/lib/model.js

@@ -57,7 +57,7 @@ export class AbstractChatModel {
             config: {
                 sendWithShiftEnter: config.sendWithShiftEnter
             },
-            onSend: (input) => this.sendMessage({ body: input })
+            onSend: this.sendMessage.bind(this)
         });
         this._commands = options.commands;
         this._activeCellManager = (_c = options.activeCellManager) !== null && _c !== void 0 ? _c : null;

package/lib/tokens.d.ts

@@ -1,18 +1,34 @@
-import { IWidgetTracker, MainAreaWidget } from '@jupyterlab/apputils';
+import { IWidgetTracker } from '@jupyterlab/apputils';
 import { Token } from '@lumino/coreutils';
 import { Widget } from '@lumino/widgets';
 import { ChatWidget, Placeholder } from './widgets';
 import { IChatModel } from './model';
+import { ChatArea } from './types';
 /**
- * The main area chat widget type.
+ * The interface for any widget displaying a chat (main area or side panel).
  */
-export type MainAreaChat = MainAreaWidget<ChatWidget> & {
+export interface IChatPanel extends Widget {
+    /**
+     * The chat widget embedded in the panel.
+     */
+    widget: ChatWidget;
+    /**
+     * The model of the chat widget.
+     */
     model: IChatModel;
-};
+    /**
+     * The area of the panel.
+     */
+    area: ChatArea;
+    /**
+     * The chat panel toolbar.
+     */
+    toolbar: Widget;
+}
 /**
  * the chat tracker type.
  */
-export type IChatTracker = IWidgetTracker<ChatWidget | MainAreaChat>;
+export type IChatTracker = IWidgetTracker<IChatPanel>;
 /**
  * A chat tracker token.
  */

package/lib/types.d.ts

@@ -161,10 +161,7 @@ export interface IChatHistory {
 /**
  * The content of a new message.
  */
-export interface INewMessage {
-    body: string;
-    id?: string;
-}
+export type INewMessage<T = IUser, U = IAttachment> = Partial<Pick<IMessageContent<T, U>, 'body' | 'attachments' | 'mentions' | 'metadata' | 'mime_model' | 'sender'>>;
 /**
  * The attachment type. Jupyter Chat allows for two types of attachments
  * currently:

package/lib/utils.d.ts

@@ -1,6 +1,10 @@
+import { ToolbarRegistry } from '@jupyterlab/apputils';
 import { CodeMirrorEditor } from '@jupyterlab/codemirror';
 import { Notebook } from '@jupyterlab/notebook';
+import { IObservableList } from '@jupyterlab/observables';
+import { CommandRegistry } from '@lumino/commands';
 import { Widget } from '@lumino/widgets';
+import { IChatPanel } from './tokens';
 import { IUser } from './types';
 /**
  * Gets the editor instance used by a document widget. Returns `null` if unable.
@@ -24,3 +28,10 @@ export declare function replaceMentionToSpan(content: string, user: IUser): stri
  * @param user - the user mentioned.
  */
 export declare function replaceSpanToMention(content: string, user: IUser): string;
+/**
+ * Wraps a toolbar factory so that every CommandToolbarButton it creates
+ * automatically receives the panel's area as an arg.
+ * This lets commands branch on `args.area` without each plugin having to
+ * register a per-item toolbarRegistry.addFactory call.
+ */
+export declare function injectAreaArg(baseFactory: (panel: IChatPanel) => IObservableList<ToolbarRegistry.IToolbarItem>, commands: CommandRegistry): (panel: IChatPanel) => IObservableList<ToolbarRegistry.IToolbarItem>;

package/lib/utils.js

@@ -2,10 +2,12 @@
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
+import { CommandToolbarButton } from '@jupyterlab/apputils';
 import { CodeMirrorEditor } from '@jupyterlab/codemirror';
 import { DocumentWidget } from '@jupyterlab/docregistry';
 import { FileEditor } from '@jupyterlab/fileeditor';
 import { Notebook } from '@jupyterlab/notebook';
+import { ObservableList } from '@jupyterlab/observables';
 const MENTION_CLASS = 'jp-chat-mention';
 /**
  * Gets the editor instance used by a document widget. Returns `null` if unable.
@@ -66,3 +68,43 @@ export function replaceSpanToMention(content, user) {
     const regex = new RegExp(mentionEl, 'g');
     return content.replace(regex, mention);
 }
+/**
+ * Wraps a toolbar factory so that every CommandToolbarButton it creates
+ * automatically receives the panel's area as an arg.
+ * This lets commands branch on `args.area` without each plugin having to
+ * register a per-item toolbarRegistry.addFactory call.
+ */
+export function injectAreaArg(baseFactory, commands) {
+    return (panel) => {
+        const base = baseFactory(panel);
+        const inject = (item) => {
+            const { widget } = item;
+            if (!(widget instanceof CommandToolbarButton)) {
+                return item;
+            }
+            return {
+                name: item.name,
+                widget: new CommandToolbarButton({
+                    commands,
+                    id: widget.commandId,
+                    args: { area: panel.area }
+                })
+            };
+        };
+        const wrapped = new ObservableList({
+            values: Array.from({ length: base.length }, (_, i) => inject(base.get(i)))
+        });
+        base.changed.connect((_, change) => {
+            if (change.type === 'add') {
+                wrapped.insertAll(change.newIndex, change.newValues.map(inject));
+            }
+            else if (change.type === 'remove') {
+                wrapped.removeRange(change.oldIndex, change.oldIndex + change.oldValues.length);
+            }
+            else if (change.type === 'set') {
+                change.newValues.forEach((item, i) => wrapped.set(change.newIndex + i, inject(item)));
+            }
+        });
+        return wrapped;
+    };
+}