@codingame/monaco-vscode-api 15.0.2 → 16.0.0

package/vscode/src/vs/base/common/network.js

@@ -149,7 +149,7 @@ class FileAccessImpl {
         return ( ( new URL(url ?? moduleId, globalThis.location?.href ?? import.meta.url)).toString());
     }
     asBrowserUri(resourcePath) {
-        const uri = this.toUri(resourcePath, { toUrl: this.toUrl.bind(this) });
+        const uri = this.toUri(resourcePath);
         return this.uriToBrowserUri(uri);
     }
     uriToBrowserUri(uri) {
@@ -171,7 +171,7 @@ class FileAccessImpl {
         return this.staticBrowserUris.get(uri) ?? uri;
     }
     asFileUri(resourcePath) {
-        const uri = this.toUri(resourcePath, { toUrl: this.toUrl.bind(this) });
+        const uri = this.toUri(resourcePath);
         return this.uriToFileUri(uri);
     }
     uriToFileUri(uri) {
@@ -185,7 +185,7 @@ class FileAccessImpl {
         }
         return uri;
     }
-    toUri(uriOrModule, moduleIdToUrl) {
+    toUri(uriOrModule) {
         if (URI.isUri(uriOrModule)) {
             return uriOrModule;
         }
@@ -197,7 +197,7 @@ class FileAccessImpl {
             const modulePath = join(rootUriOrPath, uriOrModule);
             return URI.file(modulePath);
         }
-        return ( URI.parse(moduleIdToUrl.toUrl(uriOrModule)));
+        return ( URI.parse(this.toUrl(uriOrModule)));
     }
     registerStaticBrowserUri(uri, browserUri) {
         this.staticBrowserUris.set(uri, browserUri);

package/vscode/src/vs/base/common/objects.d.ts

@@ -10,9 +10,6 @@ type obj = {
 export declare function distinct(base: obj, target: obj): obj;
 export declare function getCaseInsensitive(target: obj, key: string): unknown;
 export declare function filter(obj: obj, predicate: (key: string, value: any) => boolean): obj;
-export declare function getAllPropertyNames(obj: object): string[];
-export declare function getAllMethodNames(obj: object): string[];
-export declare function createProxyObject<T extends object>(methodNames: string[], invoke: (method: string, args: unknown[]) => unknown): T;
 export declare function mapValues<T extends {}, R>(obj: T, fn: (value: T[keyof T], key: string) => R): {
     [K in keyof T]: R;
 };

package/vscode/src/vs/base/common/objects.js

@@ -181,36 +181,6 @@ function filter(obj, predicate) {
     }
     return result;
 }
-function getAllPropertyNames(obj) {
-    let res = [];
-    while (Object.prototype !== obj) {
-        res = res.concat(Object.getOwnPropertyNames(obj));
-        obj = Object.getPrototypeOf(obj);
-    }
-    return res;
-}
-function getAllMethodNames(obj) {
-    const methods = [];
-    for (const prop of getAllPropertyNames(obj)) {
-        if (typeof obj[prop] === 'function') {
-            methods.push(prop);
-        }
-    }
-    return methods;
-}
-function createProxyObject(methodNames, invoke) {
-    const createProxyMethod = (method) => {
-        return function () {
-            const args = Array.prototype.slice.call(arguments, 0);
-            return invoke(method, args);
-        };
-    };
-    const result = {};
-    for (const methodName of methodNames) {
-        result[methodName] = createProxyMethod(methodName);
-    }
-    return result;
-}
 function mapValues(obj, fn) {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
@@ -219,4 +189,4 @@ function mapValues(obj, fn) {
     return result;
 }
 
-export { cloneAndChange, createProxyObject, deepClone, deepFreeze, distinct, equals, filter, getAllMethodNames, getAllPropertyNames, mapValues, mixin, safeStringify };
+export { cloneAndChange, deepClone, deepFreeze, distinct, equals, filter, mapValues, mixin, safeStringify };

package/vscode/src/vs/base/common/observableInternal/autorun.d.ts

@@ -30,13 +30,13 @@ export declare class AutorunObserver<TChangeSummary = any> implements IObserver,
     readonly _runFn: (reader: IReader, changeSummary: TChangeSummary) => void;
     private readonly createChangeSummary;
     private readonly _handleChange;
-    _state: AutorunState;
-    private updateCount;
-    private disposed;
-    _dependencies: Set<IObservable<any>>;
-    private dependenciesToBeRemoved;
-    private changeSummary;
-    _isRunning: boolean;
+    private _state;
+    private _updateCount;
+    private _disposed;
+    private _dependencies;
+    private _dependenciesToBeRemoved;
+    private _changeSummary;
+    private _isRunning;
     get debugName(): string;
     constructor(_debugNameData: DebugNameData, _runFn: (reader: IReader, changeSummary: TChangeSummary) => void, createChangeSummary: (() => TChangeSummary) | undefined, _handleChange: ((context: IChangeContext, summary: TChangeSummary) => boolean) | undefined);
     dispose(): void;
@@ -48,6 +48,13 @@ export declare class AutorunObserver<TChangeSummary = any> implements IObserver,
     handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
     private _isDependency;
     readObservable<T>(observable: IObservable<T>): T;
+    debugGetState(): {
+        isRunning: boolean;
+        updateCount: number;
+        dependencies: Set<IObservable<any>>;
+        state: AutorunState;
+    };
+    debugRerun(): void;
 }
 export declare namespace autorun {
     const Observer: typeof AutorunObserver;

package/vscode/src/vs/base/common/observableInternal/autorun.js

@@ -96,18 +96,18 @@ class AutorunObserver {
         this.createChangeSummary = createChangeSummary;
         this._handleChange = _handleChange;
         this._state = AutorunState.stale;
-        this.updateCount = 0;
-        this.disposed = false;
+        this._updateCount = 0;
+        this._disposed = false;
         this._dependencies = ( new Set());
-        this.dependenciesToBeRemoved = ( new Set());
+        this._dependenciesToBeRemoved = ( new Set());
         this._isRunning = false;
-        this.changeSummary = this.createChangeSummary?.();
+        this._changeSummary = this.createChangeSummary?.();
         getLogger()?.handleAutorunCreated(this);
         this._run();
         trackDisposable(this);
     }
     dispose() {
-        this.disposed = true;
+        this._disposed = true;
         for (const o of this._dependencies) {
             o.removeObserver(this);
         }
@@ -116,16 +116,16 @@ class AutorunObserver {
         markAsDisposed(this);
     }
     _run() {
-        const emptySet = this.dependenciesToBeRemoved;
-        this.dependenciesToBeRemoved = this._dependencies;
+        const emptySet = this._dependenciesToBeRemoved;
+        this._dependenciesToBeRemoved = this._dependencies;
         this._dependencies = emptySet;
         this._state = AutorunState.upToDate;
         try {
-            if (!this.disposed) {
+            if (!this._disposed) {
                 getLogger()?.handleAutorunStarted(this);
-                const changeSummary = this.changeSummary;
+                const changeSummary = this._changeSummary;
                 try {
-                    this.changeSummary = this.createChangeSummary?.();
+                    this._changeSummary = this.createChangeSummary?.();
                     this._isRunning = true;
                     this._runFn(this, changeSummary);
                 }
@@ -138,13 +138,13 @@ class AutorunObserver {
             }
         }
         finally {
-            if (!this.disposed) {
+            if (!this._disposed) {
                 getLogger()?.handleAutorunFinished(this);
             }
-            for (const o of this.dependenciesToBeRemoved) {
+            for (const o of this._dependenciesToBeRemoved) {
                 o.removeObserver(this);
             }
-            this.dependenciesToBeRemoved.clear();
+            this._dependenciesToBeRemoved.clear();
         }
     }
     toString() {
@@ -154,11 +154,11 @@ class AutorunObserver {
         if (this._state === AutorunState.upToDate) {
             this._state = AutorunState.dependenciesMightHaveChanged;
         }
-        this.updateCount++;
+        this._updateCount++;
     }
     endUpdate(_observable) {
         try {
-            if (this.updateCount === 1) {
+            if (this._updateCount === 1) {
                 do {
                     if (this._state === AutorunState.dependenciesMightHaveChanged) {
                         this._state = AutorunState.upToDate;
@@ -176,9 +176,9 @@ class AutorunObserver {
             }
         }
         finally {
-            this.updateCount--;
+            this._updateCount--;
         }
-        assertFn(() => this.updateCount >= 0);
+        assertFn(() => this._updateCount >= 0);
     }
     handlePossibleChange(observable) {
         if (this._state === AutorunState.upToDate && this._isDependency(observable)) {
@@ -193,7 +193,7 @@ class AutorunObserver {
                     changedObservable: observable,
                     change,
                     didChange: (o) => o === observable,
-                }, this.changeSummary) : true;
+                }, this._changeSummary) : true;
                 if (shouldReact) {
                     this._state = AutorunState.stale;
                 }
@@ -204,21 +204,37 @@ class AutorunObserver {
         }
     }
     _isDependency(observable) {
-        return ( this._dependencies.has(observable)) && !( this.dependenciesToBeRemoved.has(observable));
+        return ( this._dependencies.has(observable)) && !( this._dependenciesToBeRemoved.has(observable));
     }
     readObservable(observable) {
         if (!this._isRunning) {
             throw ( new BugIndicatingError('The reader object cannot be used outside its compute function!'));
         }
-        if (this.disposed) {
+        if (this._disposed) {
             return observable.get();
         }
         observable.addObserver(this);
         const value = observable.get();
         this._dependencies.add(observable);
-        this.dependenciesToBeRemoved.delete(observable);
+        this._dependenciesToBeRemoved.delete(observable);
         return value;
     }
+    debugGetState() {
+        return {
+            isRunning: this._isRunning,
+            updateCount: this._updateCount,
+            dependencies: this._dependencies,
+            state: this._state,
+        };
+    }
+    debugRerun() {
+        if (!this._isRunning) {
+            this._run();
+        }
+        else {
+            this._state = AutorunState.stale;
+        }
+    }
 }
 (function (autorun) {
     autorun.Observer = AutorunObserver;

package/vscode/src/vs/base/common/observableInternal/base.d.ts

@@ -57,13 +57,14 @@ export declare abstract class ConvenientObservable<T, TChange> implements IObser
     protected get debugValue(): T;
 }
 export declare abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
-    readonly _observers: Set<IObserver>;
+    protected readonly _observers: Set<IObserver>;
     constructor();
     addObserver(observer: IObserver): void;
     removeObserver(observer: IObserver): void;
     protected onFirstObserverAdded(): void;
     protected onLastObserverRemoved(): void;
     log(): IObservableWithChange<T, TChange>;
+    debugGetObservers(): Set<IObserver>;
 }
 export declare function transaction(fn: (tx: ITransaction) => void, getDebugName?: () => string): void;
 export declare function globalTransaction(fn: (tx: ITransaction) => void): void;
@@ -72,14 +73,15 @@ export declare function subtransaction(tx: ITransaction | undefined, fn: (tx: IT
 export declare class TransactionImpl implements ITransaction {
     readonly _fn: Function;
     private readonly _getDebugName?;
-    _updatingObservers: {
-        observer: IObserver;
-        observable: IObservable<any>;
-    }[] | null;
+    private _updatingObservers;
     constructor(_fn: Function, _getDebugName?: (() => string) | undefined);
     getDebugName(): string | undefined;
     updateObserver(observer: IObserver, observable: IObservable<any>): void;
     finish(): void;
+    debugGetUpdatingObservers(): {
+        observer: IObserver;
+        observable: IObservable<any>;
+    }[] | null;
 }
 export interface ISettableObservable<T, TChange = void> extends IObservableWithChange<T, TChange>, ISettable<T, TChange> {
 }
@@ -95,6 +97,10 @@ export declare class ObservableValue<T, TChange = void> extends BaseObservable<T
     set(value: T, tx: ITransaction | undefined, change: TChange): void;
     toString(): string;
     protected _setValue(newValue: T): void;
+    debugGetState(): {
+        value: T;
+    };
+    debugSetValue(value: unknown): void;
 }
 export declare function disposableObservableValue<T extends IDisposable | undefined, TChange = void>(nameOrOwner: string | object, initialValue: T): ISettableObservable<T, TChange> & IDisposable;
 export declare class DisposableObservableValue<T extends IDisposable | undefined, TChange = void> extends ObservableValue<T, TChange> implements IDisposable {

package/vscode/src/vs/base/common/observableInternal/base.js

@@ -1,5 +1,6 @@
 
 import { getFunctionName, DebugNameData } from './debugName.js';
+import { onUnexpectedError } from '../errors.js';
 import { strictEquals } from '../equals.js';
 import '../event.js';
 import '../lifecycle.js';
@@ -106,6 +107,9 @@ class BaseObservable extends ConvenientObservable {
         }
         return this;
     }
+    debugGetObservers() {
+        return this._observers;
+    }
 }
 function transaction(fn, getDebugName) {
     const tx = ( new TransactionImpl(fn, getDebugName));
@@ -164,11 +168,22 @@ class TransactionImpl {
         return getFunctionName(this._fn);
     }
     updateObserver(observer, observable) {
+        if (!this._updatingObservers) {
+            handleBugIndicatingErrorRecovery('Transaction already finished!');
+            transaction(tx => {
+                tx.updateObserver(observer, observable);
+            });
+            return;
+        }
         this._updatingObservers.push({ observer, observable });
         observer.beginUpdate(observable);
     }
     finish() {
         const updatingObservers = this._updatingObservers;
+        if (!updatingObservers) {
+            handleBugIndicatingErrorRecovery('transaction.finish() has already been called!');
+            return;
+        }
         for (let i = 0; i < updatingObservers.length; i++) {
             const { observer, observable } = updatingObservers[i];
             observer.endUpdate(observable);
@@ -176,6 +191,14 @@ class TransactionImpl {
         this._updatingObservers = null;
         getLogger()?.handleEndTransaction(this);
     }
+    debugGetUpdatingObservers() {
+        return this._updatingObservers;
+    }
+}
+function handleBugIndicatingErrorRecovery(message) {
+    const err = ( new Error('BugIndicatingErrorRecovery: ' + message));
+    onUnexpectedError(err);
+    console.error('recovered from an error that indicates a bug', err);
 }
 function observableValue(nameOrOwner, initialValue) {
     let debugNameData;
@@ -230,6 +253,14 @@ class ObservableValue extends BaseObservable {
     _setValue(newValue) {
         this._value = newValue;
     }
+    debugGetState() {
+        return {
+            value: this._value,
+        };
+    }
+    debugSetValue(value) {
+        this._value = value;
+    }
 }
 function disposableObservableValue(nameOrOwner, initialValue) {
     let debugNameData;

package/vscode/src/vs/base/common/observableInternal/derived.d.ts

@@ -30,14 +30,14 @@ export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T,
     private readonly _handleChange;
     private readonly _handleLastObserverRemoved;
     private readonly _equalityComparator;
-    _state: DerivedState;
-    private value;
-    _updateCount: number;
-    _dependencies: Set<IObservable<any>>;
-    private dependenciesToBeRemoved;
-    private changeSummary;
+    private _state;
+    private _value;
+    private _updateCount;
+    private _dependencies;
+    private _dependenciesToBeRemoved;
+    private _changeSummary;
     private _isUpdating;
-    _isComputing: boolean;
+    private _isComputing;
     get debugName(): string;
     constructor(_debugNameData: DebugNameData, _computeFn: (reader: IReader, changeSummary: TChangeSummary) => T, createChangeSummary: (() => TChangeSummary) | undefined, _handleChange: ((context: IChangeContext, summary: TChangeSummary) => boolean) | undefined, _handleLastObserverRemoved: (() => void) | undefined, _equalityComparator: EqualityComparer<T>);
     protected onLastObserverRemoved(): void;
@@ -53,6 +53,14 @@ export declare class Derived<T, TChangeSummary = any> extends BaseObservable<T,
     readObservable<T>(observable: IObservable<T>): T;
     addObserver(observer: IObserver): void;
     removeObserver(observer: IObserver): void;
+    debugGetState(): {
+        state: DerivedState;
+        updateCount: number;
+        isComputing: boolean;
+        dependencies: Set<IObservable<any>>;
+        value: T | undefined;
+    };
+    debugSetValue(newValue: unknown): void;
 }
 export declare class DerivedWithSetter<T, TChangeSummary = any> extends Derived<T, TChangeSummary> implements ISettableObservable<T> {
     readonly set: (value: T, tx: ITransaction | undefined) => void;

package/vscode/src/vs/base/common/observableInternal/derived.js

@@ -97,20 +97,20 @@ class Derived extends BaseObservable {
         this._handleLastObserverRemoved = _handleLastObserverRemoved;
         this._equalityComparator = _equalityComparator;
         this._state = DerivedState.initial;
-        this.value = undefined;
+        this._value = undefined;
         this._updateCount = 0;
         this._dependencies = ( new Set());
-        this.dependenciesToBeRemoved = ( new Set());
-        this.changeSummary = undefined;
+        this._dependenciesToBeRemoved = ( new Set());
+        this._changeSummary = undefined;
         this._isUpdating = false;
         this._isComputing = false;
         this._removedObserverToCallEndUpdateOn = null;
         this._isReaderValid = false;
-        this.changeSummary = this.createChangeSummary?.();
+        this._changeSummary = this.createChangeSummary?.();
     }
     onLastObserverRemoved() {
         this._state = DerivedState.initial;
-        this.value = undefined;
+        this._value = undefined;
         getLogger()?.handleDerivedCleared(this);
         for (const d of this._dependencies) {
             d.removeObserver(this);
@@ -148,36 +148,36 @@ class Derived extends BaseObservable {
                     this._recompute();
                 }
             } while (this._state !== DerivedState.upToDate);
-            return this.value;
+            return this._value;
         }
     }
     _recompute() {
-        const emptySet = this.dependenciesToBeRemoved;
-        this.dependenciesToBeRemoved = this._dependencies;
+        const emptySet = this._dependenciesToBeRemoved;
+        this._dependenciesToBeRemoved = this._dependencies;
         this._dependencies = emptySet;
         const hadValue = this._state !== DerivedState.initial;
-        const oldValue = this.value;
+        const oldValue = this._value;
         this._state = DerivedState.upToDate;
         let didChange = false;
         this._isComputing = true;
         try {
-            const changeSummary = this.changeSummary;
-            this.changeSummary = this.createChangeSummary?.();
+            const changeSummary = this._changeSummary;
+            this._changeSummary = this.createChangeSummary?.();
             try {
                 this._isReaderValid = true;
-                this.value = this._computeFn(this, changeSummary);
+                this._value = this._computeFn(this, changeSummary);
             }
             finally {
                 this._isReaderValid = false;
-                for (const o of this.dependenciesToBeRemoved) {
+                for (const o of this._dependenciesToBeRemoved) {
                     o.removeObserver(this);
                 }
-                this.dependenciesToBeRemoved.clear();
+                this._dependenciesToBeRemoved.clear();
             }
-            didChange = hadValue && !(this._equalityComparator(oldValue, this.value));
+            didChange = hadValue && !(this._equalityComparator(oldValue, this._value));
             getLogger()?.handleObservableUpdated(this, {
                 oldValue,
-                newValue: this.value,
+                newValue: this._value,
                 change: undefined,
                 didChange,
                 hadValue,
@@ -240,7 +240,7 @@ class Derived extends BaseObservable {
         assertFn(() => this._updateCount >= 0);
     }
     handlePossibleChange(observable) {
-        if (this._state === DerivedState.upToDate && ( this._dependencies.has(observable)) && !( this.dependenciesToBeRemoved.has(observable))) {
+        if (this._state === DerivedState.upToDate && ( this._dependencies.has(observable)) && !( this._dependenciesToBeRemoved.has(observable))) {
             this._state = DerivedState.dependenciesMightHaveChanged;
             for (const r of this._observers) {
                 r.handlePossibleChange(this);
@@ -248,7 +248,7 @@ class Derived extends BaseObservable {
         }
     }
     handleChange(observable, change) {
-        if (( this._dependencies.has(observable)) && !( this.dependenciesToBeRemoved.has(observable))) {
+        if (( this._dependencies.has(observable)) && !( this._dependenciesToBeRemoved.has(observable))) {
             getLogger()?.handleDerivedDependencyChanged(this, observable, change);
             let shouldReact = false;
             try {
@@ -256,7 +256,7 @@ class Derived extends BaseObservable {
                     changedObservable: observable,
                     change,
                     didChange: (o) => o === observable,
-                }, this.changeSummary) : true;
+                }, this._changeSummary) : true;
             }
             catch (e) {
                 onBugIndicatingError(e);
@@ -279,7 +279,7 @@ class Derived extends BaseObservable {
         observable.addObserver(this);
         const value = observable.get();
         this._dependencies.add(observable);
-        this.dependenciesToBeRemoved.delete(observable);
+        this._dependenciesToBeRemoved.delete(observable);
         return value;
     }
     addObserver(observer) {
@@ -303,6 +303,18 @@ class Derived extends BaseObservable {
         }
         super.removeObserver(observer);
     }
+    debugGetState() {
+        return {
+            state: this._state,
+            updateCount: this._updateCount,
+            isComputing: this._isComputing,
+            dependencies: this._dependencies,
+            value: this._value,
+        };
+    }
+    debugSetValue(newValue) {
+        this._value = newValue;
+    }
 }
 class DerivedWithSetter extends Derived {
     constructor(debugNameData, computeFn, createChangeSummary, handleChange, handleLastObserverRemoved = undefined, equalityComparator, set) {

package/vscode/src/vs/base/common/observableInternal/index.d.ts

@@ -2,7 +2,7 @@ export { observableValueOpts } from "./api.js";
 export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges } from "./autorun.js";
 export { asyncTransaction, disposableObservableValue, globalTransaction, observableValue, subtransaction, transaction, TransactionImpl, type IChangeContext, type IChangeTracker, type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction, } from "./base.js";
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from "./derived.js";
-export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "@codingame/monaco-vscode-168b98e5-dc20-5807-b1f9-798f1f92b37f-common/vscode/vs/base/common/observableInternal/promise";
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from "@codingame/monaco-vscode-ae8a8ca1-f243-508b-9c37-c88ebbd295fa-common/vscode/vs/base/common/observableInternal/promise";
 export { derivedWithCancellationToken, waitForState } from "./utilsCancellation.js";
 export { constObservable, debouncedObservableDeprecated, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithStore, signalFromObservable, ValueWithChangeEventFromObservable, wasEventTriggeredRecently, type IObservableSignal, } from "./utils.js";
 export { type DebugOwner } from "./debugName.js";

package/vscode/src/vs/base/common/observableInternal/index.js

@@ -2,11 +2,16 @@
 import '../arrays.js';
 import '../event.js';
 import '../lifecycle.js';
-import { setLogObservableFn } from './logging/logging.js';
+import { setLogObservableFn, addLogger } from './logging/logging.js';
 export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges } from './autorun.js';
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from './derived.js';
 import '../cancellation.js';
 export { ValueWithChangeEventFromObservable, constObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithStore, wasEventTriggeredRecently } from './utils.js';
 import { logObservableToConsole } from './logging/consoleObservableLogger.js';
+import { DevToolsLogger } from './logging/debugger/devToolsLogger.js';
+import { env } from '../process.js';
 
 setLogObservableFn(logObservableToConsole);
+if (env && env['VSCODE_DEV_DEBUG']) {
+    addLogger(DevToolsLogger.getInstance());
+}

package/vscode/src/vs/base/common/observableInternal/logging/debugger/debuggerRpc.d.ts

@@ -0,0 +1,4 @@
+import { API, SimpleTypedRpcConnection, MakeSideAsync } from "./rpc.js";
+export declare function registerDebugChannel<T extends {
+    channelId: string;
+} & API>(channelId: T["channelId"], createClient: () => T["client"]): SimpleTypedRpcConnection<MakeSideAsync<T["host"]>>;

package/vscode/src/vs/base/common/observableInternal/logging/debugger/debuggerRpc.js

@@ -0,0 +1,63 @@
+
+import { SimpleTypedRpcConnection } from './rpc.js';
+
+function registerDebugChannel(channelId, createClient) {
+    const g = globalThis;
+    let queuedNotifications = [];
+    let curHost = undefined;
+    const { channel, handler } = createChannelFactoryFromDebugChannel({
+        sendNotification: (data) => {
+            if (curHost) {
+                curHost.sendNotification(data);
+            }
+            else {
+                queuedNotifications.push(data);
+            }
+        },
+    });
+    let curClient = undefined;
+    (g.$$debugValueEditor_debugChannels ?? (g.$$debugValueEditor_debugChannels = {}))[channelId] = (host) => {
+        curClient = createClient();
+        curHost = host;
+        for (const n of queuedNotifications) {
+            host.sendNotification(n);
+        }
+        queuedNotifications = [];
+        return handler;
+    };
+    return SimpleTypedRpcConnection.createClient(channel, () => {
+        if (!curClient) {
+            throw ( new Error('Not supported'));
+        }
+        return curClient;
+    });
+}
+function createChannelFactoryFromDebugChannel(host) {
+    let h;
+    const channel = (handler) => {
+        h = handler;
+        return {
+            sendNotification: data => {
+                host.sendNotification(data);
+            },
+            sendRequest: data => {
+                throw ( new Error('not supported'));
+            },
+        };
+    };
+    return {
+        channel: channel,
+        handler: {
+            handleRequest: (data) => {
+                if (data.type === 'notification') {
+                    return h?.handleNotification(data.data);
+                }
+                else {
+                    return h?.handleRequest(data.data);
+                }
+            },
+        },
+    };
+}
+
+export { registerDebugChannel };