@codingame/monaco-vscode-telemetry-service-override 36.2.7 → 37.0.0

package/index.js

@@ -4,7 +4,7 @@ import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { TelemetryService } from './vscode/src/vs/workbench/services/telemetry/browser/telemetryService.js';
 import { IDataChannelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel.service';
-import { DataChannelService } from './vscode/src/vs/workbench/services/dataChannel/browser/dataChannelService.js';
+import { DataChannelService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/dataChannel/browser/dataChannelService';
 import './vscode/src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.js';
 import './vscode/src/vs/workbench/contrib/editTelemetry/browser/editTelemetry.contribution.js';
 import './vscode/src/vs/workbench/contrib/bracketPairColorizer2Telemetry/browser/bracketPairColorizer2Telemetry.contribution.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-telemetry-service-override",
-  "version": "36.2.7",
+  "version": "37.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - telemetry service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "36.2.7",
+    "@codingame/monaco-vscode-api": "37.0.0",
     "@microsoft/1ds-core-js": "3.2.18",
     "@microsoft/1ds-post-js": "3.2.18"
   },

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

@@ -0,0 +1,29 @@
+export interface IArcTextReplacement {
+    readonly start: number;
+    readonly endExclusive: number;
+    readonly text: string;
+}
+export interface IArcTextEdit {
+    readonly replacements: readonly IArcTextReplacement[];
+}
+export interface IEditArcLineCountInfo {
+    readonly deletedLineCounts: number;
+    readonly insertedLineCounts: number;
+}
+export interface IEditArcValues extends IEditArcLineCountInfo {
+    readonly arc: number;
+}
+/**
+ * Tracks how many characters from an initial edit survive later edits.
+ */
+export declare class EditArcTracker {
+    private readonly _valueBeforeTrackedEdit;
+    private readonly _trackedEdit;
+    private _updatedTrackedEdit;
+    constructor(_valueBeforeTrackedEdit: string, trackedEdit: IArcTextEdit);
+    getOriginalCharacterCount(): number;
+    handleEdits(edit: IArcTextEdit): void;
+    getAcceptedRestrainedCharactersCount(): number;
+    getLineCountInfo(): IEditArcLineCountInfo;
+    getValues(): IEditArcValues;
+}

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

@@ -0,0 +1,291 @@
+
+import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { commonPrefixLength, commonSuffixLength, splitLines } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+
+class EditArcTracker {
+    constructor(_valueBeforeTrackedEdit, trackedEdit) {
+        this._valueBeforeTrackedEdit = _valueBeforeTrackedEdit;
+        this._trackedEdit = normalizeReplacements(removeCommonText(trackedEdit.replacements, _valueBeforeTrackedEdit, true));
+        this._updatedTrackedEdit = this._trackedEdit;
+    }
+    getOriginalCharacterCount() {
+        let result = 0;
+        for (const replacement of this._trackedEdit) {
+            result += replacement.text.length;
+        }
+        return result;
+    }
+    handleEdits(edit) {
+        const untrackedEdit = normalizeReplacements(( edit.replacements.map(replacement => ({
+            ...replacement,
+            isTracked: false
+        }))));
+        this._updatedTrackedEdit = compose(this._updatedTrackedEdit, untrackedEdit);
+    }
+    getAcceptedRestrainedCharactersCount() {
+        let result = 0;
+        for (const replacement of this._updatedTrackedEdit) {
+            if (replacement.isTracked) {
+                result += replacement.text.length;
+            }
+        }
+        return result;
+    }
+    getLineCountInfo() {
+        return getLineCountInfo(
+            this._updatedTrackedEdit.filter(replacement => replacement.isTracked),
+            this._valueBeforeTrackedEdit
+        );
+    }
+    getValues() {
+        return {
+            arc: this.getAcceptedRestrainedCharactersCount(),
+            ...this.getLineCountInfo()
+        };
+    }
+}
+function removeCommonText(replacements, originalText, isTracked) {
+    return ( replacements.map(replacement => {
+        const oldText = originalText.substring(replacement.start, replacement.endExclusive);
+        const prefixLength = commonPrefixLength(oldText, replacement.text);
+        const suffixLength = Math.min(
+            oldText.length - prefixLength,
+            replacement.text.length - prefixLength,
+            commonSuffixLength(oldText, replacement.text)
+        );
+        return {
+            start: replacement.start + prefixLength,
+            endExclusive: replacement.endExclusive - suffixLength,
+            text: replacement.text.substring(prefixLength, replacement.text.length - suffixLength),
+            isTracked
+        };
+    }));
+}
+function normalizeReplacements(replacements) {
+    const result = [];
+    let previous;
+    for (const replacement of replacements) {
+        if (replacement.start > replacement.endExclusive) {
+            throw ( new BugIndicatingError("Edit replacement start must not be after its end"));
+        }
+        if (previous && replacement.start < previous.endExclusive) {
+            throw ( new BugIndicatingError("Edit replacements must be sorted and disjoint"));
+        }
+        if (replacement.start === replacement.endExclusive && replacement.text.length === 0) {
+            continue;
+        }
+        if (previous && previous.endExclusive === replacement.start && previous.isTracked === replacement.isTracked) {
+            previous = {
+                start: previous.start,
+                endExclusive: replacement.endExclusive,
+                text: previous.text + replacement.text,
+                isTracked: previous.isTracked
+            };
+            continue;
+        }
+        if (previous) {
+            result.push(previous);
+        }
+        previous = replacement;
+    }
+    if (previous) {
+        result.push(previous);
+    }
+    return result;
+}
+function compose(first, second) {
+    if (first.length === 0) {
+        return second.slice();
+    }
+    if (second.length === 0) {
+        return first.slice();
+    }
+    const firstQueue = first.slice();
+    const result = [];
+    let firstToSecondOffset = 0;
+    for (const secondReplacement of second) {
+        while (true) {
+            const firstReplacement = firstQueue[0];
+            if (!firstReplacement || firstReplacement.start + firstToSecondOffset + firstReplacement.text.length >= secondReplacement.start) {
+                break;
+            }
+            firstQueue.shift();
+            result.push(firstReplacement);
+            firstToSecondOffset += firstReplacement.text.length - (firstReplacement.endExclusive - firstReplacement.start);
+        }
+        const offsetBeforeIntersections = firstToSecondOffset;
+        let firstIntersecting;
+        let lastIntersecting;
+        while (true) {
+            const firstReplacement = firstQueue[0];
+            if (!firstReplacement || firstReplacement.start + firstToSecondOffset > secondReplacement.endExclusive) {
+                break;
+            }
+            firstIntersecting ??= firstReplacement;
+            lastIntersecting = firstReplacement;
+            firstQueue.shift();
+            firstToSecondOffset += firstReplacement.text.length - (firstReplacement.endExclusive - firstReplacement.start);
+        }
+        if (!firstIntersecting) {
+            result.push(deltaReplacement(secondReplacement, -firstToSecondOffset));
+            continue;
+        }
+        const replaceStart = Math.min(
+            firstIntersecting.start,
+            secondReplacement.start - offsetBeforeIntersections
+        );
+        const prefixLength = secondReplacement.start - (firstIntersecting.start + offsetBeforeIntersections);
+        if (prefixLength > 0) {
+            result.push(
+                sliceReplacement(firstIntersecting, replaceStart, replaceStart, 0, prefixLength)
+            );
+        }
+        if (!lastIntersecting) {
+            throw ( new BugIndicatingError("Missing intersecting ARC edit"));
+        }
+        const suffixLength = lastIntersecting.endExclusive + firstToSecondOffset - secondReplacement.endExclusive;
+        if (suffixLength > 0) {
+            const suffix = sliceReplacement(
+                lastIntersecting,
+                lastIntersecting.endExclusive,
+                lastIntersecting.endExclusive,
+                lastIntersecting.text.length - suffixLength,
+                lastIntersecting.text.length
+            );
+            firstQueue.unshift(suffix);
+            firstToSecondOffset -= suffix.text.length - (suffix.endExclusive - suffix.start);
+        }
+        result.push(sliceReplacement(
+            secondReplacement,
+            replaceStart,
+            secondReplacement.endExclusive - firstToSecondOffset,
+            0,
+            secondReplacement.text.length
+        ));
+    }
+    result.push(...firstQueue);
+    return normalizeReplacements(result);
+}
+function deltaReplacement(replacement, offset) {
+    return {
+        ...replacement,
+        start: replacement.start + offset,
+        endExclusive: replacement.endExclusive + offset
+    };
+}
+function sliceReplacement(replacement, start, endExclusive, textStart, textEndExclusive) {
+    return {
+        start,
+        endExclusive,
+        text: replacement.text.substring(textStart, textEndExclusive),
+        isTracked: replacement.isTracked
+    };
+}
+function getLineCountInfo(replacements, initialText) {
+    if (replacements.length === 0) {
+        return {
+            deletedLineCounts: 0,
+            insertedLineCounts: 0
+        };
+    }
+    const lineOffsets = ( new LineOffsets(initialText));
+    const textReplacements = ( replacements.map(replacement => ({
+        start: lineOffsets.getPosition(replacement.start),
+        end: lineOffsets.getPosition(replacement.endExclusive),
+        startOffset: replacement.start,
+        endOffset: replacement.endExclusive,
+        text: replacement.text
+    })));
+    let deletedLineCounts = 0;
+    let insertedLineCounts = 0;
+    let current = [];
+    for (let i = 0; i < textReplacements.length; i++) {
+        const replacement = textReplacements[i];
+        const next = textReplacements[i + 1];
+        current.push(replacement);
+        if (next && next.start.lineNumber === replacement.end.lineNumber) {
+            continue;
+        }
+        const joined = joinTextReplacements(current, initialText);
+        current = [];
+        const newLines = splitLines(joined.text);
+        let startLineNumber = joined.start.lineNumber;
+        let endLineNumberExclusive = joined.end.lineNumber + 1;
+        const firstLinePrefix = initialText.substring(lineOffsets.getLineStart(joined.start.lineNumber), joined.startOffset);
+        newLines[0] = firstLinePrefix + newLines[0];
+        const lastLineSuffix = initialText.substring(joined.endOffset, lineOffsets.getLineEnd(joined.end.lineNumber));
+        newLines[newLines.length - 1] += lastLineSuffix;
+        const startsAtLineEnd = joined.start.column === lineOffsets.getLineLength(joined.start.lineNumber) + 1;
+        const endsAtLineStart = joined.end.column === 1;
+        if (startsAtLineEnd && newLines[0].length === firstLinePrefix.length) {
+            startLineNumber++;
+            newLines.shift();
+        }
+        if (newLines.length > 0 && startLineNumber < endLineNumberExclusive && endsAtLineStart && newLines[newLines.length - 1].length === lastLineSuffix.length) {
+            endLineNumberExclusive--;
+            newLines.pop();
+        }
+        deletedLineCounts += endLineNumberExclusive - startLineNumber;
+        insertedLineCounts += newLines.length;
+    }
+    return {
+        deletedLineCounts,
+        insertedLineCounts
+    };
+}
+function joinTextReplacements(replacements, initialText) {
+    const first = replacements[0];
+    const last = replacements[replacements.length - 1];
+    let text = first.text;
+    for (let i = 1; i < replacements.length; i++) {
+        text += initialText.substring(replacements[i - 1].endOffset, replacements[i].startOffset);
+        text += replacements[i].text;
+    }
+    return {
+        start: first.start,
+        end: last.end,
+        startOffset: first.startOffset,
+        endOffset: last.endOffset,
+        text
+    };
+}
+class LineOffsets {
+    constructor(text) {
+        this._lineStarts = [0];
+        this._lineEnds = [];
+        for (let i = 0; i < text.length; i++) {
+            if (text.charCodeAt(i) === 10) {
+                this._lineStarts.push(i + 1);
+                this._lineEnds.push(i > 0 && text.charCodeAt(i - 1) === 13 ? i - 1 : i);
+            }
+        }
+        this._lineEnds.push(text.length);
+    }
+    getPosition(offset) {
+        let low = 0;
+        let high = this._lineStarts.length - 1;
+        while (low < high) {
+            const middle = Math.ceil((low + high) / 2);
+            if (this._lineStarts[middle] <= offset) {
+                low = middle;
+            } else {
+                high = middle - 1;
+            }
+        }
+        return {
+            lineNumber: low + 1,
+            column: offset - this._lineStarts[low] + 1
+        };
+    }
+    getLineStart(lineNumber) {
+        return this._lineStarts[lineNumber - 1];
+    }
+    getLineEnd(lineNumber) {
+        return this._lineEnds[lineNumber - 1];
+    }
+    getLineLength(lineNumber) {
+        return this.getLineEnd(lineNumber) - this.getLineStart(lineNumber);
+    }
+}
+
+export { EditArcTracker };

package/vscode/src/vs/platform/agentHost/common/diffComputeService.d.ts

@@ -0,0 +1,19 @@
+import { IArcTextReplacement } from "../../../base/common/editArcTracker.js";
+export interface IDiffCountResult {
+    added: number;
+    removed: number;
+    changes: readonly IOffsetEdit[];
+}
+export interface IOffsetEdit {
+    startOffset: number;
+    endOffsetExclusive: number;
+    newText: string;
+}
+export interface IDetailedDiffResult {
+    added: number;
+    removed: number;
+    replacements: readonly IArcTextReplacement[];
+    hitTimeout: boolean;
+}
+/** Default timeout for diff computation in milliseconds. */
+export declare const DEFAULT_DIFF_TIMEOUT_MS = 5000;

package/vscode/src/vs/platform/agentHost/common/fileEditAttribution.d.ts

@@ -0,0 +1,107 @@
+import { IOffsetEdit } from "./diffComputeService.js";
+import { ToolResultFileEditContent } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { EditTelemetryTrigger } from "../../telemetry/common/editTelemetry.js";
+import { IAgentEditAttributionService } from "./fileEditAttribution.service.js";
+export declare const FILE_EDIT_ATTRIBUTION_PROPERTY = "_vscodeEditAttribution";
+export declare const MAX_EDIT_ATTRIBUTION_FILE_SIZE: number;
+interface IFileEditAttributionMarkerBase {
+    readonly version: 1;
+    readonly editId: string;
+    readonly sequence: number;
+}
+export interface IFileEditAttributionSource {
+    readonly modelId?: string;
+    readonly conversationId: string;
+    readonly requestId: string;
+    readonly harness: string;
+}
+export interface ITrackedFileEditAttributionMarker extends IFileEditAttributionMarkerBase {
+    readonly status?: "tracked";
+    readonly beforeDigest: string;
+    readonly afterDigest: string;
+    readonly source?: IFileEditAttributionSource;
+}
+export interface ISkippedFileEditAttributionMarker extends IFileEditAttributionMarkerBase {
+    readonly status: "skipped";
+    readonly reason: "fileTooLarge";
+    readonly untrackedEditCount?: number;
+    readonly insertedCount: number;
+}
+export type IFileEditAttributionMarker = ITrackedFileEditAttributionMarker | ISkippedFileEditAttributionMarker;
+export type AttributedToolResultFileEditContent = ToolResultFileEditContent & {
+    readonly [FILE_EDIT_ATTRIBUTION_PROPERTY]: IFileEditAttributionMarker;
+};
+export interface IAgentEditAttribution {
+    readonly sessionUri: string;
+    readonly turnId: string;
+    readonly toolCallId: string;
+    readonly filePath: string;
+    readonly beforeText: string;
+    readonly afterText: string;
+    readonly changes: readonly IOffsetEdit[];
+    readonly modelId: string | undefined;
+    readonly toolName: string;
+}
+export declare class NullAgentEditAttributionService implements IAgentEditAttributionService {
+    readonly _serviceBrand: undefined;
+    setEnabled(_enabled: boolean): void;
+    recordEdit(_edit: IAgentEditAttribution): Promise<IFileEditAttributionMarker | undefined>;
+    flushSession(_sessionUri: string): Promise<void>;
+    prepareFlush(_params: IPrepareEditAttributionFlushParams): Promise<IPreparedEditAttributionFlush | undefined>;
+    commitFlush(_params: ICommitEditAttributionFlushParams): Promise<IEditAttributionFlushResult>;
+    cancelFlush(_params: ICancelEditAttributionFlushParams): Promise<IEditAttributionFlushResult>;
+}
+export interface IPrepareEditAttributionFlushParams {
+    readonly resource: URI;
+    readonly trigger: EditTelemetryTrigger;
+    readonly statsUuid: string;
+    readonly isDirty: boolean;
+    readonly flushToken: string;
+    readonly languageId: string;
+}
+export interface IPreparedEditAttributionFlush {
+    readonly flushToken: string;
+    readonly agentModifiedCount: number;
+    readonly lastSequence?: number;
+    readonly coverageGapThroughSequence?: number;
+    readonly standaloneCoverageGapAcknowledgements?: readonly IEditAttributionCoverageGapAcknowledgement[];
+}
+export interface IEditAttributionCoverageGapAcknowledgement {
+    readonly id: string;
+    readonly sequences: readonly number[];
+    readonly editCount: number;
+    readonly insertedCount: number;
+}
+export interface ICommitEditAttributionFlushParams {
+    readonly flushToken: string;
+    readonly totalModifiedCount: number;
+}
+export interface ICancelEditAttributionFlushParams {
+    readonly flushToken: string;
+}
+export type EditAttributionFlushOutcome = "committed" | "cancelled" | "missing";
+export interface IEditAttributionFlushResult {
+    readonly outcome: EditAttributionFlushOutcome;
+    readonly agentModifiedCount: number;
+    readonly lastSequence?: number;
+    readonly coverageGapThroughSequence?: number;
+    readonly standaloneCoverageGapAcknowledgements?: readonly IEditAttributionCoverageGapAcknowledgement[];
+}
+export declare function getFileEditAttributionMarker(content: ToolResultFileEditContent): IFileEditAttributionMarker | undefined;
+export declare function createFileEditContentDigest(content: string): string;
+export declare function buildPrepareEditAttributionResource(params: IPrepareEditAttributionFlushParams): URI;
+export declare function buildCommitEditAttributionResource(params: ICommitEditAttributionFlushParams): URI;
+export declare function buildCancelEditAttributionResource(params: ICancelEditAttributionFlushParams): URI;
+export type EditAttributionResourceRequest = {
+    readonly kind: "prepare";
+    readonly params: IPrepareEditAttributionFlushParams;
+} | {
+    readonly kind: "commit";
+    readonly params: ICommitEditAttributionFlushParams;
+} | {
+    readonly kind: "cancel";
+    readonly params: ICancelEditAttributionFlushParams;
+};
+export declare function parseEditAttributionResource(resource: URI): EditAttributionResourceRequest | undefined;
+export {};

package/vscode/src/vs/platform/agentHost/common/fileEditAttribution.js

@@ -0,0 +1,59 @@
+
+import { stringHash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+
+const FILE_EDIT_ATTRIBUTION_PROPERTY = "_vscodeEditAttribution";
+const EDIT_ATTRIBUTION_RESOURCE_SCHEME = "agent-edit-attribution";
+function getFileEditAttributionMarker(content) {
+    const marker = content[FILE_EDIT_ATTRIBUTION_PROPERTY];
+    if (marker?.version !== 1 || typeof marker.editId !== "string" || !Number.isSafeInteger(marker.sequence) || marker.sequence < 0) {
+        return undefined;
+    }
+    if (marker.status === "skipped") {
+        return marker.reason === "fileTooLarge" && (marker.untrackedEditCount === undefined || (Number.isSafeInteger(marker.untrackedEditCount) && marker.untrackedEditCount > 0)) && Number.isSafeInteger(marker.insertedCount) && marker.insertedCount >= 0 ? marker : undefined;
+    }
+    if (marker.status !== undefined && marker.status !== "tracked") {
+        return undefined;
+    }
+    if (typeof marker.beforeDigest !== "string" || typeof marker.afterDigest !== "string" || (marker.source !== undefined && !isFileEditAttributionSource(marker.source))) {
+        return undefined;
+    }
+    return marker;
+}
+function isFileEditAttributionSource(source) {
+    if (typeof source !== "object" || source === null || Array.isArray(source)) {
+        return false;
+    }
+    const candidate = source;
+    return (candidate.modelId === undefined || typeof candidate.modelId === "string") && typeof candidate.conversationId === "string" && typeof candidate.requestId === "string" && typeof candidate.harness === "string";
+}
+function createFileEditContentDigest(content) {
+    return `${content.length}:${stringHash(content, 0)}:${stringHash(content, 5381)}`;
+}
+function buildPrepareEditAttributionResource(params) {
+    return buildEditAttributionResource("prepare", {
+        resource: ( params.resource.toString()),
+        trigger: params.trigger,
+        statsUuid: params.statsUuid,
+        isDirty: params.isDirty,
+        flushToken: params.flushToken,
+        languageId: params.languageId
+    });
+}
+function buildCommitEditAttributionResource(params) {
+    return buildEditAttributionResource("commit", params);
+}
+function buildCancelEditAttributionResource(params) {
+    return buildEditAttributionResource("cancel", params);
+}
+function buildEditAttributionResource(kind, value) {
+    const params = ( new URLSearchParams());
+    params.set("payload", JSON.stringify(value));
+    return ( URI.from({
+        scheme: EDIT_ATTRIBUTION_RESOURCE_SCHEME,
+        path: `/${kind}`,
+        query: ( params.toString())
+    }));
+}
+
+export { FILE_EDIT_ATTRIBUTION_PROPERTY, buildCancelEditAttributionResource, buildCommitEditAttributionResource, buildPrepareEditAttributionResource, createFileEditContentDigest, getFileEditAttributionMarker };

package/vscode/src/vs/platform/agentHost/common/fileEditAttribution.service.d.ts

@@ -0,0 +1,12 @@
+import { IAgentEditAttribution, IFileEditAttributionMarker, IPrepareEditAttributionFlushParams, IPreparedEditAttributionFlush, ICommitEditAttributionFlushParams, IEditAttributionFlushResult, ICancelEditAttributionFlushParams } from "./fileEditAttribution.js";
+export declare const IAgentEditAttributionService: import("@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IAgentEditAttributionService>;
+export interface IAgentEditAttributionService {
+    readonly _serviceBrand: undefined;
+    /** Disabling attribution is permanent for the lifetime of the service. */
+    setEnabled(enabled: boolean): void;
+    recordEdit(edit: IAgentEditAttribution): Promise<IFileEditAttributionMarker | undefined>;
+    flushSession(sessionUri: string): Promise<void>;
+    prepareFlush(params: IPrepareEditAttributionFlushParams): Promise<IPreparedEditAttributionFlush | undefined>;
+    commitFlush(params: ICommitEditAttributionFlushParams): Promise<IEditAttributionFlushResult>;
+    cancelFlush(params: ICancelEditAttributionFlushParams): Promise<IEditAttributionFlushResult>;
+}

package/vscode/src/vs/platform/telemetry/browser/errorTelemetry.js

@@ -1,6 +1,6 @@
 
 import { mainWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/window';
-import { getRecentDisposableResizeObserverAttributionForLoopError } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { getRecentDisposableResizeObserverContextForLoopError } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
 import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import BaseErrorTelemetry from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/errorTelemetry';
@@ -45,10 +45,10 @@ class ErrorTelemetry extends BaseErrorTelemetry {
                     : err.stack;
             }
         }
-        const resizeObserverAttribution = getRecentDisposableResizeObserverAttributionForLoopError(msg);
-        if (resizeObserverAttribution) {
-            data.msg = resizeObserverAttribution;
-            data.callstack = resizeObserverAttribution;
+        const resizeObserverContext = getRecentDisposableResizeObserverContextForLoopError(msg);
+        if (resizeObserverContext) {
+            data.msg = resizeObserverContext;
+            data.callstack = resizeObserverContext;
         }
         this._enqueue(data);
     }

package/vscode/src/vs/platform/telemetry/common/1dsAppender.d.ts

@@ -6,6 +6,8 @@ export interface IAppInsightsCore {
     track(item: ITelemetryItem | IExtendedTelemetryItem): void;
     unload(isAsync: boolean, unloadComplete: (unloadState: ITelemetryUnloadState) => void): void;
 }
+/** Fills in the envelope fields every event needs, including the internal-only routing flag. */
+export declare function applyEnvelopeDefaults(envelope: ITelemetryItem, isInternalMachine: boolean | undefined): void;
 export declare abstract class AbstractOneDataSystemAppender implements ITelemetryAppender {
     private readonly _isInternalTelemetry;
     private _eventPrefix;

package/vscode/src/vs/platform/telemetry/common/1dsAppender.js

@@ -5,6 +5,16 @@ import { validateTelemetryData } from '@codingame/monaco-vscode-api/vscode/vs/pl
 
 const endpointUrl = "https://mobile.events.data.microsoft.com/OneCollector/1.0";
 const endpointHealthUrl = "https://mobile.events.data.microsoft.com/ping";
+function applyEnvelopeDefaults(envelope, isInternalMachine) {
+    envelope["ext"] = envelope["ext"] ?? {};
+    envelope["ext"]["web"] = envelope["ext"]["web"] ?? {};
+    envelope["ext"]["web"]["consentDetails"] = "{\"GPC_DataSharingOptIn\":false}";
+    const baseData = envelope["baseData"];
+    if (isInternalMachine || baseData?.measurements?.["common.msftInternal"] === 1) {
+        envelope["ext"]["utc"] = envelope["ext"]["utc"] ?? {};
+        envelope["ext"]["utc"]["flags"] = 0x0000811ECD;
+    }
+}
 async function getClient(instrumentationKey, addInternalFlag, xhrOverride) {
     const oneDs = await import('@microsoft/1ds-core-js');
     const postPlugin = await import('@microsoft/1ds-post-js');
@@ -30,15 +40,7 @@ async function getClient(instrumentationKey, addInternalFlag, xhrOverride) {
         coreConfig.extensionConfig[collectorChannelPlugin.identifier] = channelConfig;
     }
     appInsightsCore.initialize(coreConfig, []);
-    appInsightsCore.addTelemetryInitializer(envelope => {
-        envelope["ext"] = envelope["ext"] ?? {};
-        envelope["ext"]["web"] = envelope["ext"]["web"] ?? {};
-        envelope["ext"]["web"]["consentDetails"] = "{\"GPC_DataSharingOptIn\":false}";
-        if (addInternalFlag) {
-            envelope["ext"]["utc"] = envelope["ext"]["utc"] ?? {};
-            envelope["ext"]["utc"]["flags"] = 0x0000811ECD;
-        }
-    });
+    appInsightsCore.addTelemetryInitializer(envelope => applyEnvelopeDefaults(envelope, addInternalFlag));
     return appInsightsCore;
 }
 class AbstractOneDataSystemAppender {
@@ -119,4 +121,4 @@ class AbstractOneDataSystemAppender {
     }
 }
 
-export { AbstractOneDataSystemAppender };
+export { AbstractOneDataSystemAppender, applyEnvelopeDefaults };