@sanity/cli 6.0.0-alpha.9 → 6.0.0

package/dist/util/telemetry/cleanupOldTelemetryFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/cleanupOldTelemetryFiles.ts"],"sourcesContent":["import {rm, stat} from 'node:fs/promises'\n\nimport {findTelemetryFiles} from './findTelemetryFiles.js'\nimport {telemetryStoreDebug} from './telemetryStoreDebug.js'\n\n/**\n * Cleans up telemetry files older than the specified number of days\n * @internal\n */\nexport async function cleanupOldTelemetryFiles(maxAgeDays: number = 7): Promise<void> {\n  try {\n    const files = await findTelemetryFiles()\n    const cutoffTime = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000\n\n    for (const filePath of files) {\n      try {\n        const stats = await stat(filePath)\n        if (stats.mtime.getTime() < cutoffTime) {\n          telemetryStoreDebug('Cleaning up old telemetry file: %s', filePath)\n          await rm(filePath, {force: true})\n        }\n      } catch (error) {\n        telemetryStoreDebug('Error checking/removing old file %s: %o', filePath, error)\n      }\n    }\n  } catch (error) {\n    telemetryStoreDebug('Error during cleanup: %o', error)\n    // Don't throw - cleanup is best effort\n  }\n}\n"],"names":["rm","stat","findTelemetryFiles","telemetryStoreDebug","cleanupOldTelemetryFiles","maxAgeDays","files","cutoffTime","Date","now","filePath","stats","mtime","getTime","force","error"],"mappings":"AAAA,SAAQA,EAAE,EAAEC,IAAI,QAAO,mBAAkB;AAEzC,SAAQC,kBAAkB,QAAO,0BAAyB;AAC1D,SAAQC,mBAAmB,QAAO,2BAA0B;AAE5D;;;CAGC,GACD,OAAO,eAAeC,yBAAyBC,aAAqB,CAAC;IACnE,IAAI;QACF,MAAMC,QAAQ,MAAMJ;QACpB,MAAMK,aAAaC,KAAKC,GAAG,KAAKJ,aAAa,KAAK,KAAK,KAAK;QAE5D,KAAK,MAAMK,YAAYJ,MAAO;YAC5B,IAAI;gBACF,MAAMK,QAAQ,MAAMV,KAAKS;gBACzB,IAAIC,MAAMC,KAAK,CAACC,OAAO,KAAKN,YAAY;oBACtCJ,oBAAoB,sCAAsCO;oBAC1D,MAAMV,GAAGU,UAAU;wBAACI,OAAO;oBAAI;gBACjC;YACF,EAAE,OAAOC,OAAO;gBACdZ,oBAAoB,2CAA2CO,UAAUK;YAC3E;QACF;IACF,EAAE,OAAOA,OAAO;QACdZ,oBAAoB,4BAA4BY;IAChD,uCAAuC;IACzC;AACF"}

package/dist/util/telemetry/createTelemetryStore.js

@@ -0,0 +1,95 @@
+import { appendFileSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { generateTelemetryFilePath } from './generateTelemetryFilePath.js';
+import { createLogger } from './logger.js';
+import { telemetryStoreDebug } from './telemetryStoreDebug.js';
+/**
+ * Creates a file-based telemetry store with cached consent and reliable synchronous I/O.
+ *
+ * Key optimizations:
+ * - Consent resolved once at creation and cached (vs checking on every emit)
+ * - File path generated and directory created once during initialization
+ * - Synchronous file writes to ensure events are captured even during process exit
+ *
+ * @param sessionId - Unique session identifier for file isolation
+ * @param options - Configuration options
+ * @returns TelemetryStore instance compatible with the telemetry interface
+ *
+ * @internal
+ */ export function createTelemetryStore(sessionId, options) {
+    telemetryStoreDebug('Creating telemetry store with sessionId: %s', sessionId);
+    let cachedConsent = null;
+    let filePath = null;
+    const initializeConsent = async ()=>{
+        if (cachedConsent) return;
+        try {
+            cachedConsent = await options.resolveConsent();
+            telemetryStoreDebug('Cached consent status: %s', cachedConsent.status);
+        } catch (error) {
+            telemetryStoreDebug('Failed to initialize consent, treating as undetermined: %o', error);
+            cachedConsent = {
+                reason: 'fetchError',
+                status: 'undetermined'
+            };
+        }
+    };
+    const initializeFilePath = async ()=>{
+        if (filePath) return;
+        try {
+            filePath = await generateTelemetryFilePath(sessionId);
+            telemetryStoreDebug('Generated file path: %s', filePath);
+            await mkdir(dirname(filePath), {
+                recursive: true
+            });
+            telemetryStoreDebug('Created directory structure for: %s', filePath);
+        } catch (error) {
+            telemetryStoreDebug('Failed to initialize file path: %o', error);
+            filePath = null;
+        }
+    };
+    const emit = (event)=>{
+        if (!cachedConsent || cachedConsent.status !== 'granted') {
+            if (cachedConsent) {
+                telemetryStoreDebug('Cached consent not granted (%s), skipping event: %s', cachedConsent.status, event.type);
+            } else {
+                telemetryStoreDebug('Consent not resolved, skipping event: %s', event.type);
+            }
+            return;
+        }
+        if (!filePath) {
+            telemetryStoreDebug('File path not initialized, skipping event: %s', event.type);
+            return;
+        }
+        telemetryStoreDebug('Emitting event: %s', event.type);
+        try {
+            const eventLine = JSON.stringify(event) + '\n';
+            // We use synchronous file writes to ensure telemetry events are captured even when
+            // the process exits abruptly (process.exit, uncaught exceptions, SIGTERM, etc.).
+            // The performance impact is probably negligible and is worth the trade-off
+            // for 100% reliability. Async writes would be lost when the event loop
+            // shuts down during process exit.
+            appendFileSync(filePath, eventLine, 'utf8');
+            telemetryStoreDebug('Successfully wrote event to file: %s', filePath);
+        } catch (error) {
+            telemetryStoreDebug('Failed to write telemetry event: %o', error);
+        // Silent failure - don't break CLI functionality
+        }
+    };
+    const logger = createLogger(sessionId, emit);
+    // Initialize both consent and file path concurrently
+    Promise.allSettled([
+        initializeConsent(),
+        initializeFilePath()
+    ]).then((results)=>{
+        for (const [index, result] of results.entries()){
+            if (result.status === 'rejected') {
+                const type = index === 0 ? 'consent' : 'file path';
+                telemetryStoreDebug('Error initializing %s: %o', type, result.reason);
+            }
+        }
+    });
+    return logger;
+}
+
+//# sourceMappingURL=createTelemetryStore.js.map

package/dist/util/telemetry/createTelemetryStore.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/createTelemetryStore.ts"],"sourcesContent":["import {appendFileSync} from 'node:fs'\nimport {mkdir} from 'node:fs/promises'\nimport {dirname} from 'node:path'\n\nimport {\n  type CLITelemetryStore,\n  type ConsentInformation,\n  type TelemetryUserProperties,\n} from '@sanity/cli-core'\nimport {type TelemetryEvent} from '@sanity/telemetry'\n\nimport {generateTelemetryFilePath} from './generateTelemetryFilePath.js'\nimport {createLogger} from './logger.js'\nimport {telemetryStoreDebug} from './telemetryStoreDebug.js'\n\n/**\n * FILE MANAGEMENT STRATEGY:\n *\n * The telemetry system uses a multi-file approach to handle concurrent CLI processes:\n *\n * 1. WRITING (per session):\n *    - Each CLI session gets a unique file: telemetry-\\{hash\\}-\\{env\\}-\\{sessionId\\}.ndjson\n *    - Prevents write conflicts when multiple CLI commands run simultaneously\n *    - Events are written using an RxJS queue for ordered processing with retry logic\n *\n * 2. FLUSHING (aggregate all sessions):\n *    - findTelemetryFiles() discovers ALL telemetry files for user/environment\n *    - Events are collected from all session files and sent as a batch\n *    - Files are deleted after successful transmission\n *\n * 3. CLEANUP (background maintenance):\n *    - cleanupOldTelemetryFiles() removes stale files older than 7 days\n *    - Prevents disk space accumulation from abandoned sessions\n */\n\ninterface CreateTelemetryStoreOptions {\n  resolveConsent: () => Promise<ConsentInformation>\n}\n\n/**\n * Creates a file-based telemetry store with cached consent and reliable synchronous I/O.\n *\n * Key optimizations:\n * - Consent resolved once at creation and cached (vs checking on every emit)\n * - File path generated and directory created once during initialization\n * - Synchronous file writes to ensure events are captured even during process exit\n *\n * @param sessionId - Unique session identifier for file isolation\n * @param options - Configuration options\n * @returns TelemetryStore instance compatible with the telemetry interface\n *\n * @internal\n */\nexport function createTelemetryStore(\n  sessionId: string,\n  options: CreateTelemetryStoreOptions,\n): CLITelemetryStore {\n  telemetryStoreDebug('Creating telemetry store with sessionId: %s', sessionId)\n\n  let cachedConsent: ConsentInformation | null = null\n  let filePath: string | null = null\n\n  const initializeConsent = async () => {\n    if (cachedConsent) return\n\n    try {\n      cachedConsent = await options.resolveConsent()\n      telemetryStoreDebug('Cached consent status: %s', cachedConsent.status)\n    } catch (error) {\n      telemetryStoreDebug('Failed to initialize consent, treating as undetermined: %o', error)\n      cachedConsent = {reason: 'fetchError', status: 'undetermined'}\n    }\n  }\n\n  const initializeFilePath = async () => {\n    if (filePath) return\n\n    try {\n      filePath = await generateTelemetryFilePath(sessionId)\n      telemetryStoreDebug('Generated file path: %s', filePath)\n\n      await mkdir(dirname(filePath), {recursive: true})\n      telemetryStoreDebug('Created directory structure for: %s', filePath)\n    } catch (error) {\n      telemetryStoreDebug('Failed to initialize file path: %o', error)\n      filePath = null\n    }\n  }\n\n  const emit = (event: TelemetryEvent) => {\n    if (!cachedConsent || cachedConsent.status !== 'granted') {\n      if (cachedConsent) {\n        telemetryStoreDebug(\n          'Cached consent not granted (%s), skipping event: %s',\n          cachedConsent.status,\n          event.type,\n        )\n      } else {\n        telemetryStoreDebug('Consent not resolved, skipping event: %s', event.type)\n      }\n      return\n    }\n\n    if (!filePath) {\n      telemetryStoreDebug('File path not initialized, skipping event: %s', event.type)\n      return\n    }\n\n    telemetryStoreDebug('Emitting event: %s', event.type)\n\n    try {\n      const eventLine = JSON.stringify(event) + '\\n'\n\n      // We use synchronous file writes to ensure telemetry events are captured even when\n      // the process exits abruptly (process.exit, uncaught exceptions, SIGTERM, etc.).\n      // The performance impact is probably negligible and is worth the trade-off\n      // for 100% reliability. Async writes would be lost when the event loop\n      // shuts down during process exit.\n      appendFileSync(filePath, eventLine, 'utf8')\n      telemetryStoreDebug('Successfully wrote event to file: %s', filePath)\n    } catch (error) {\n      telemetryStoreDebug('Failed to write telemetry event: %o', error)\n      // Silent failure - don't break CLI functionality\n    }\n  }\n\n  const logger = createLogger<TelemetryUserProperties>(sessionId, emit)\n\n  // Initialize both consent and file path concurrently\n  Promise.allSettled([initializeConsent(), initializeFilePath()]).then((results) => {\n    for (const [index, result] of results.entries()) {\n      if (result.status === 'rejected') {\n        const type = index === 0 ? 'consent' : 'file path'\n        telemetryStoreDebug('Error initializing %s: %o', type, result.reason)\n      }\n    }\n  })\n\n  return logger\n}\n"],"names":["appendFileSync","mkdir","dirname","generateTelemetryFilePath","createLogger","telemetryStoreDebug","createTelemetryStore","sessionId","options","cachedConsent","filePath","initializeConsent","resolveConsent","status","error","reason","initializeFilePath","recursive","emit","event","type","eventLine","JSON","stringify","logger","Promise","allSettled","then","results","index","result","entries"],"mappings":"AAAA,SAAQA,cAAc,QAAO,UAAS;AACtC,SAAQC,KAAK,QAAO,mBAAkB;AACtC,SAAQC,OAAO,QAAO,YAAW;AASjC,SAAQC,yBAAyB,QAAO,iCAAgC;AACxE,SAAQC,YAAY,QAAO,cAAa;AACxC,SAAQC,mBAAmB,QAAO,2BAA0B;AA0B5D;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,qBACdC,SAAiB,EACjBC,OAAoC;IAEpCH,oBAAoB,+CAA+CE;IAEnE,IAAIE,gBAA2C;IAC/C,IAAIC,WAA0B;IAE9B,MAAMC,oBAAoB;QACxB,IAAIF,eAAe;QAEnB,IAAI;YACFA,gBAAgB,MAAMD,QAAQI,cAAc;YAC5CP,oBAAoB,6BAA6BI,cAAcI,MAAM;QACvE,EAAE,OAAOC,OAAO;YACdT,oBAAoB,8DAA8DS;YAClFL,gBAAgB;gBAACM,QAAQ;gBAAcF,QAAQ;YAAc;QAC/D;IACF;IAEA,MAAMG,qBAAqB;QACzB,IAAIN,UAAU;QAEd,IAAI;YACFA,WAAW,MAAMP,0BAA0BI;YAC3CF,oBAAoB,2BAA2BK;YAE/C,MAAMT,MAAMC,QAAQQ,WAAW;gBAACO,WAAW;YAAI;YAC/CZ,oBAAoB,uCAAuCK;QAC7D,EAAE,OAAOI,OAAO;YACdT,oBAAoB,sCAAsCS;YAC1DJ,WAAW;QACb;IACF;IAEA,MAAMQ,OAAO,CAACC;QACZ,IAAI,CAACV,iBAAiBA,cAAcI,MAAM,KAAK,WAAW;YACxD,IAAIJ,eAAe;gBACjBJ,oBACE,uDACAI,cAAcI,MAAM,EACpBM,MAAMC,IAAI;YAEd,OAAO;gBACLf,oBAAoB,4CAA4Cc,MAAMC,IAAI;YAC5E;YACA;QACF;QAEA,IAAI,CAACV,UAAU;YACbL,oBAAoB,iDAAiDc,MAAMC,IAAI;YAC/E;QACF;QAEAf,oBAAoB,sBAAsBc,MAAMC,IAAI;QAEpD,IAAI;YACF,MAAMC,YAAYC,KAAKC,SAAS,CAACJ,SAAS;YAE1C,mFAAmF;YACnF,iFAAiF;YACjF,2EAA2E;YAC3E,uEAAuE;YACvE,kCAAkC;YAClCnB,eAAeU,UAAUW,WAAW;YACpChB,oBAAoB,wCAAwCK;QAC9D,EAAE,OAAOI,OAAO;YACdT,oBAAoB,uCAAuCS;QAC3D,iDAAiD;QACnD;IACF;IAEA,MAAMU,SAASpB,aAAsCG,WAAWW;IAEhE,qDAAqD;IACrDO,QAAQC,UAAU,CAAC;QAACf;QAAqBK;KAAqB,EAAEW,IAAI,CAAC,CAACC;QACpE,KAAK,MAAM,CAACC,OAAOC,OAAO,IAAIF,QAAQG,OAAO,GAAI;YAC/C,IAAID,OAAOjB,MAAM,KAAK,YAAY;gBAChC,MAAMO,OAAOS,UAAU,IAAI,YAAY;gBACvCxB,oBAAoB,6BAA6Be,MAAMU,OAAOf,MAAM;YACtE;QACF;IACF;IAEA,OAAOS;AACT"}

package/dist/util/telemetry/createTraceId.js

@@ -0,0 +1,10 @@
+import { typeid } from 'typeid-js';
+/**
+ * Creates a unique trace ID using typeid
+ *
+ * @internal
+ */ export function createTraceId() {
+    return typeid('trace').toString();
+}
+
+//# sourceMappingURL=createTraceId.js.map

package/dist/util/telemetry/createTraceId.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/createTraceId.ts"],"sourcesContent":["import {typeid} from 'typeid-js'\n\ntype TraceId = string & {__type: 'TraceId'}\n\n/**\n * Creates a unique trace ID using typeid\n *\n * @internal\n */\nexport function createTraceId(): TraceId {\n  return typeid('trace').toString() as TraceId\n}\n"],"names":["typeid","createTraceId","toString"],"mappings":"AAAA,SAAQA,MAAM,QAAO,YAAW;AAIhC;;;;CAIC,GACD,OAAO,SAASC;IACd,OAAOD,OAAO,SAASE,QAAQ;AACjC"}

package/dist/util/telemetry/findTelemetryFiles.js

@@ -0,0 +1,35 @@
+import { join } from 'node:path';
+import { getTelemetryBaseInfo, normalizePath } from '@sanity/cli-core';
+import { glob } from 'tinyglobby';
+import { telemetryStoreDebug } from './telemetryStoreDebug.js';
+/**
+ * Discovers and returns paths to all telemetry files for the current user/environment.
+ *
+ * This function is used during:
+ * - Flush operations: to collect and send events from all CLI sessions
+ * - Cleanup operations: to find old files that should be removed
+ *
+ * Uses glob patterns to match files across all sessions (not just the current one).
+ *
+ * @returns Promise resolving to array of file paths, empty if no files exist
+ * @internal
+ */ export async function findTelemetryFiles() {
+    try {
+        const { basePattern, directory } = await getTelemetryBaseInfo();
+        const pattern = `${basePattern}-*.ndjson`;
+        const fullPattern = join(directory, pattern);
+        telemetryStoreDebug('Looking for files matching pattern: %s', fullPattern);
+        // Converts windows backslashes to forward slashes for glob pattern
+        const matchingFiles = await glob(normalizePath(fullPattern));
+        telemetryStoreDebug('Found %d matching telemetry files', matchingFiles.length);
+        return matchingFiles;
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            telemetryStoreDebug('Telemetry directory does not exist yet');
+            return [];
+        }
+        throw error;
+    }
+}
+
+//# sourceMappingURL=findTelemetryFiles.js.map

package/dist/util/telemetry/findTelemetryFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/findTelemetryFiles.ts"],"sourcesContent":["import {join} from 'node:path'\n\nimport {getTelemetryBaseInfo, normalizePath} from '@sanity/cli-core'\nimport {glob} from 'tinyglobby'\n\nimport {telemetryStoreDebug} from './telemetryStoreDebug.js'\n\n/**\n * Discovers and returns paths to all telemetry files for the current user/environment.\n *\n * This function is used during:\n * - Flush operations: to collect and send events from all CLI sessions\n * - Cleanup operations: to find old files that should be removed\n *\n * Uses glob patterns to match files across all sessions (not just the current one).\n *\n * @returns Promise resolving to array of file paths, empty if no files exist\n * @internal\n */\nexport async function findTelemetryFiles(): Promise<string[]> {\n  try {\n    const {basePattern, directory} = await getTelemetryBaseInfo()\n    const pattern = `${basePattern}-*.ndjson`\n    const fullPattern = join(directory, pattern)\n    telemetryStoreDebug('Looking for files matching pattern: %s', fullPattern)\n\n    // Converts windows backslashes to forward slashes for glob pattern\n    const matchingFiles = await glob(normalizePath(fullPattern))\n    telemetryStoreDebug('Found %d matching telemetry files', matchingFiles.length)\n    return matchingFiles\n  } catch (error) {\n    if ((error as {code?: string}).code === 'ENOENT') {\n      telemetryStoreDebug('Telemetry directory does not exist yet')\n      return []\n    }\n    throw error\n  }\n}\n"],"names":["join","getTelemetryBaseInfo","normalizePath","glob","telemetryStoreDebug","findTelemetryFiles","basePattern","directory","pattern","fullPattern","matchingFiles","length","error","code"],"mappings":"AAAA,SAAQA,IAAI,QAAO,YAAW;AAE9B,SAAQC,oBAAoB,EAAEC,aAAa,QAAO,mBAAkB;AACpE,SAAQC,IAAI,QAAO,aAAY;AAE/B,SAAQC,mBAAmB,QAAO,2BAA0B;AAE5D;;;;;;;;;;;CAWC,GACD,OAAO,eAAeC;IACpB,IAAI;QACF,MAAM,EAACC,WAAW,EAAEC,SAAS,EAAC,GAAG,MAAMN;QACvC,MAAMO,UAAU,GAAGF,YAAY,SAAS,CAAC;QACzC,MAAMG,cAAcT,KAAKO,WAAWC;QACpCJ,oBAAoB,0CAA0CK;QAE9D,mEAAmE;QACnE,MAAMC,gBAAgB,MAAMP,KAAKD,cAAcO;QAC/CL,oBAAoB,qCAAqCM,cAAcC,MAAM;QAC7E,OAAOD;IACT,EAAE,OAAOE,OAAO;QACd,IAAI,AAACA,MAA0BC,IAAI,KAAK,UAAU;YAChDT,oBAAoB;YACpB,OAAO,EAAE;QACX;QACA,MAAMQ;IACR;AACF"}

package/dist/util/telemetry/flushTelemetryFiles.js

@@ -0,0 +1,118 @@
+import { rm } from 'node:fs/promises';
+import { catchError, defer, from, lastValueFrom, map, mergeMap, of, reduce, switchMap, tap } from 'rxjs';
+import { cleanupOldTelemetryFiles } from './cleanupOldTelemetryFiles.js';
+import { findTelemetryFiles } from './findTelemetryFiles.js';
+import { readNDJSON } from './readNDJSON.js';
+import { telemetryStoreDebug } from './telemetryStoreDebug.js';
+/**
+ * Standalone, stateless function to flush telemetry files.
+ *
+ * This function can be used independently of the telemetry store, making it
+ * suitable for use in child processes or other contexts where store state
+ * is not available.
+ *
+ * @param options - Configuration for consent resolution and event sending
+ * @returns Promise that resolves when flush operation is complete
+ *
+ * @internal
+ */ export async function flushTelemetryFiles(options) {
+    telemetryStoreDebug('Starting standalone flush operation');
+    // Helper function for deleting files with consistent error handling
+    const deleteFiles = (files, reason)=>{
+        if (files.length === 0) {
+            // of() is not same as of(undefined) in rxjs
+            // eslint-disable-next-line unicorn/no-useless-undefined
+            return of(undefined);
+        }
+        return from(files).pipe(mergeMap((filePath)=>from(rm(filePath, {
+                force: true
+            })).pipe(tap(()=>{
+                telemetryStoreDebug(`Deleted file ${reason}: %s`, filePath);
+            }), catchError((error)=>{
+                telemetryStoreDebug('Error deleting file %s: %o', filePath, error);
+                // of() is not same as of(undefined) in rxjs
+                // eslint-disable-next-line unicorn/no-useless-undefined
+                return of(undefined);
+            }))), // Collect all deletions into a single completion value
+        reduce(()=>undefined, undefined));
+    };
+    const flush$ = defer(()=>from(options.resolveConsent())).pipe(tap((currentConsent)=>{
+        telemetryStoreDebug('Current consent status for flush: %s', currentConsent.status);
+    }), switchMap((currentConsent)=>{
+        // First cleanup old files, then process current files
+        return defer(()=>from(cleanupOldTelemetryFiles())).pipe(switchMap(()=>defer(()=>from(findTelemetryFiles()))), switchMap((filePaths)=>{
+            if (filePaths.length === 0) {
+                telemetryStoreDebug('No telemetry files found, nothing to flush');
+                return of({
+                    allEvents: [],
+                    consent: currentConsent,
+                    emptyFiles: [],
+                    filesToDelete: []
+                });
+            }
+            telemetryStoreDebug('Found %d telemetry files to process', filePaths.length);
+            return from(filePaths).pipe(mergeMap((filePath)=>{
+                return defer(()=>from(readNDJSON(filePath))).pipe(tap((events)=>{
+                    telemetryStoreDebug('Read %d events from %s', events.length, filePath);
+                }), catchError((error)=>{
+                    if (error.code === 'ENOENT') {
+                        telemetryStoreDebug('File %s no longer exists, skipping', filePath);
+                        return of([]);
+                    }
+                    telemetryStoreDebug('Error reading file %s: %o', filePath, error);
+                    return of([]);
+                }), map((events)=>({
+                        events,
+                        filePath
+                    })));
+            }), reduce((acc, current)=>{
+                if (current.events.length > 0) {
+                    acc.allEvents.push(...current.events);
+                    acc.filesToDelete.push(current.filePath);
+                } else {
+                    acc.emptyFiles.push(current.filePath);
+                }
+                return acc;
+            }, {
+                allEvents: [],
+                emptyFiles: [],
+                filesToDelete: []
+            }), map((result)=>({
+                    ...result,
+                    consent: currentConsent
+                })));
+        }));
+    }), switchMap(({ allEvents, consent, emptyFiles, filesToDelete })=>{
+        telemetryStoreDebug('Found %d total events to flush from %d files (%d empty)', allEvents.length, filesToDelete.length, emptyFiles.length);
+        // Always clean up empty files regardless of consent or event count
+        const cleanupEmpty$ = emptyFiles.length > 0 ? deleteFiles(emptyFiles, 'empty files') : of(undefined);
+        if (consent.status !== 'granted' || allEvents.length === 0) {
+            if (consent.status === 'granted') {
+                telemetryStoreDebug('No events to send, cleaning up files');
+                return cleanupEmpty$;
+            } else {
+                telemetryStoreDebug('Consent not granted (%s), cleaning up %d files without sending events', consent.status, filesToDelete.length);
+                return deleteFiles([
+                    ...filesToDelete,
+                    ...emptyFiles
+                ], `without sending (consent: ${consent.status})`);
+            }
+        }
+        // Send events and then delete all files (including empty ones)
+        telemetryStoreDebug('Sending %d events to backend', allEvents.length);
+        return defer(()=>from(options.sendEvents(allEvents))).pipe(tap(()=>{
+            telemetryStoreDebug('Successfully sent events, deleting %d files', filesToDelete.length);
+        }), switchMap(()=>deleteFiles([
+                ...filesToDelete,
+                ...emptyFiles
+            ], 'after successful send')));
+    }), tap(()=>{
+        telemetryStoreDebug('Standalone flush operation completed successfully');
+    }), map(()=>undefined), catchError((error)=>{
+        telemetryStoreDebug('Error during standalone flush operation: %o', error);
+        throw error;
+    }));
+    return lastValueFrom(flush$);
+}
+
+//# sourceMappingURL=flushTelemetryFiles.js.map

package/dist/util/telemetry/flushTelemetryFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/flushTelemetryFiles.ts"],"sourcesContent":["import {rm} from 'node:fs/promises'\n\nimport {type ConsentInformation} from '@sanity/cli-core'\nimport {type TelemetryEvent} from '@sanity/telemetry'\nimport {\n  catchError,\n  defer,\n  from,\n  lastValueFrom,\n  map,\n  mergeMap,\n  of,\n  reduce,\n  switchMap,\n  tap,\n} from 'rxjs'\n\nimport {cleanupOldTelemetryFiles} from './cleanupOldTelemetryFiles.js'\nimport {findTelemetryFiles} from './findTelemetryFiles.js'\nimport {readNDJSON} from './readNDJSON.js'\nimport {telemetryStoreDebug} from './telemetryStoreDebug.js'\n\ninterface FlushTelemetryFilesOptions {\n  resolveConsent: () => Promise<ConsentInformation>\n  sendEvents: (events: TelemetryEvent[]) => Promise<void>\n}\n\n/**\n * Standalone, stateless function to flush telemetry files.\n *\n * This function can be used independently of the telemetry store, making it\n * suitable for use in child processes or other contexts where store state\n * is not available.\n *\n * @param options - Configuration for consent resolution and event sending\n * @returns Promise that resolves when flush operation is complete\n *\n * @internal\n */\nexport async function flushTelemetryFiles(options: FlushTelemetryFilesOptions): Promise<void> {\n  telemetryStoreDebug('Starting standalone flush operation')\n\n  // Helper function for deleting files with consistent error handling\n  const deleteFiles = (files: string[], reason: string) => {\n    if (files.length === 0) {\n      // of() is not same as of(undefined) in rxjs\n      // eslint-disable-next-line unicorn/no-useless-undefined\n      return of(undefined)\n    }\n\n    return from(files).pipe(\n      mergeMap((filePath) =>\n        from(rm(filePath, {force: true})).pipe(\n          tap(() => {\n            telemetryStoreDebug(`Deleted file ${reason}: %s`, filePath)\n          }),\n          catchError((error) => {\n            telemetryStoreDebug('Error deleting file %s: %o', filePath, error)\n            // of() is not same as of(undefined) in rxjs\n            // eslint-disable-next-line unicorn/no-useless-undefined\n            return of(undefined)\n          }),\n        ),\n      ),\n      // Collect all deletions into a single completion value\n      reduce(() => undefined as void, undefined as void),\n    )\n  }\n\n  const flush$ = defer(() => from(options.resolveConsent())).pipe(\n    tap((currentConsent) => {\n      telemetryStoreDebug('Current consent status for flush: %s', currentConsent.status)\n    }),\n    switchMap((currentConsent) => {\n      // First cleanup old files, then process current files\n      return defer(() => from(cleanupOldTelemetryFiles())).pipe(\n        switchMap(() => defer(() => from(findTelemetryFiles()))),\n        switchMap((filePaths) => {\n          if (filePaths.length === 0) {\n            telemetryStoreDebug('No telemetry files found, nothing to flush')\n            return of({allEvents: [], consent: currentConsent, emptyFiles: [], filesToDelete: []})\n          }\n\n          telemetryStoreDebug('Found %d telemetry files to process', filePaths.length)\n\n          return from(filePaths).pipe(\n            mergeMap((filePath) => {\n              return defer(() => from(readNDJSON<TelemetryEvent>(filePath))).pipe(\n                tap((events) => {\n                  telemetryStoreDebug('Read %d events from %s', events.length, filePath)\n                }),\n                catchError((error) => {\n                  if ((error as {code?: string}).code === 'ENOENT') {\n                    telemetryStoreDebug('File %s no longer exists, skipping', filePath)\n                    return of([])\n                  }\n                  telemetryStoreDebug('Error reading file %s: %o', filePath, error)\n                  return of([])\n                }),\n                map((events) => ({events, filePath})),\n              )\n            }),\n            reduce(\n              (\n                acc: {allEvents: TelemetryEvent[]; emptyFiles: string[]; filesToDelete: string[]},\n                current,\n              ) => {\n                if (current.events.length > 0) {\n                  acc.allEvents.push(...current.events)\n                  acc.filesToDelete.push(current.filePath)\n                } else {\n                  acc.emptyFiles.push(current.filePath)\n                }\n                return acc\n              },\n              {allEvents: [], emptyFiles: [], filesToDelete: []},\n            ),\n            map((result) => ({...result, consent: currentConsent})),\n          )\n        }),\n      )\n    }),\n    switchMap(({allEvents, consent, emptyFiles, filesToDelete}) => {\n      telemetryStoreDebug(\n        'Found %d total events to flush from %d files (%d empty)',\n        allEvents.length,\n        filesToDelete.length,\n        emptyFiles.length,\n      )\n\n      // Always clean up empty files regardless of consent or event count\n      const cleanupEmpty$ =\n        emptyFiles.length > 0 ? deleteFiles(emptyFiles, 'empty files') : of(undefined as void)\n\n      if (consent.status !== 'granted' || allEvents.length === 0) {\n        if (consent.status === 'granted') {\n          telemetryStoreDebug('No events to send, cleaning up files')\n          return cleanupEmpty$\n        } else {\n          telemetryStoreDebug(\n            'Consent not granted (%s), cleaning up %d files without sending events',\n            consent.status,\n            filesToDelete.length,\n          )\n          return deleteFiles(\n            [...filesToDelete, ...emptyFiles],\n            `without sending (consent: ${consent.status})`,\n          )\n        }\n      }\n\n      // Send events and then delete all files (including empty ones)\n      telemetryStoreDebug('Sending %d events to backend', allEvents.length)\n\n      return defer(() => from(options.sendEvents(allEvents))).pipe(\n        tap(() => {\n          telemetryStoreDebug('Successfully sent events, deleting %d files', filesToDelete.length)\n        }),\n        switchMap(() => deleteFiles([...filesToDelete, ...emptyFiles], 'after successful send')),\n      )\n    }),\n    tap(() => {\n      telemetryStoreDebug('Standalone flush operation completed successfully')\n    }),\n    map(() => undefined as void),\n    catchError((error) => {\n      telemetryStoreDebug('Error during standalone flush operation: %o', error)\n      throw error\n    }),\n  )\n\n  return lastValueFrom(flush$)\n}\n"],"names":["rm","catchError","defer","from","lastValueFrom","map","mergeMap","of","reduce","switchMap","tap","cleanupOldTelemetryFiles","findTelemetryFiles","readNDJSON","telemetryStoreDebug","flushTelemetryFiles","options","deleteFiles","files","reason","length","undefined","pipe","filePath","force","error","flush$","resolveConsent","currentConsent","status","filePaths","allEvents","consent","emptyFiles","filesToDelete","events","code","acc","current","push","result","cleanupEmpty$","sendEvents"],"mappings":"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"}

package/dist/util/telemetry/generateTelemetryFilePath.js

@@ -0,0 +1,30 @@
+import { join } from 'node:path';
+import { getTelemetryBaseInfo } from '@sanity/cli-core';
+import { telemetryStoreDebug } from './telemetryStoreDebug.js';
+/**
+ * Generates a unique telemetry file path for a specific CLI session.
+ *
+ * File format: `telemetry-\{hashedToken\}-\{env\}-\{sessionId\}.ndjson`
+ *
+ * The sessionId ensures each CLI process writes to its own file, preventing:
+ * - File write conflicts when multiple CLI commands run concurrently
+ * - Race conditions during file operations
+ * - Data corruption from simultaneous writes
+ *
+ * During flush, all session files are discovered and aggregated together.
+ *
+ * @param sessionId - Unique identifier for this CLI session
+ * @returns Promise resolving to the full file path for this session's telemetry
+ * @internal
+ */ export async function generateTelemetryFilePath(sessionId) {
+    telemetryStoreDebug('Generating telemetry file path for sessionId: %s', sessionId);
+    const { basePattern, directory, environment, hashedToken } = await getTelemetryBaseInfo();
+    telemetryStoreDebug('Generated token hash: %s', hashedToken);
+    telemetryStoreDebug('Detected environment: %s', environment);
+    const fileName = `${basePattern}-${sessionId}.ndjson`;
+    const filePath = join(directory, fileName);
+    telemetryStoreDebug('Telemetry file path: %s', filePath);
+    return filePath;
+}
+
+//# sourceMappingURL=generateTelemetryFilePath.js.map

package/dist/util/telemetry/generateTelemetryFilePath.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/generateTelemetryFilePath.ts"],"sourcesContent":["import {join} from 'node:path'\n\nimport {getTelemetryBaseInfo} from '@sanity/cli-core'\n\nimport {telemetryStoreDebug} from './telemetryStoreDebug.js'\n\n/**\n * Generates a unique telemetry file path for a specific CLI session.\n *\n * File format: `telemetry-\\{hashedToken\\}-\\{env\\}-\\{sessionId\\}.ndjson`\n *\n * The sessionId ensures each CLI process writes to its own file, preventing:\n * - File write conflicts when multiple CLI commands run concurrently\n * - Race conditions during file operations\n * - Data corruption from simultaneous writes\n *\n * During flush, all session files are discovered and aggregated together.\n *\n * @param sessionId - Unique identifier for this CLI session\n * @returns Promise resolving to the full file path for this session's telemetry\n * @internal\n */\nexport async function generateTelemetryFilePath(sessionId: string): Promise<string> {\n  telemetryStoreDebug('Generating telemetry file path for sessionId: %s', sessionId)\n\n  const {basePattern, directory, environment, hashedToken} = await getTelemetryBaseInfo()\n\n  telemetryStoreDebug('Generated token hash: %s', hashedToken)\n  telemetryStoreDebug('Detected environment: %s', environment)\n\n  const fileName = `${basePattern}-${sessionId}.ndjson`\n  const filePath = join(directory, fileName)\n  telemetryStoreDebug('Telemetry file path: %s', filePath)\n\n  return filePath\n}\n"],"names":["join","getTelemetryBaseInfo","telemetryStoreDebug","generateTelemetryFilePath","sessionId","basePattern","directory","environment","hashedToken","fileName","filePath"],"mappings":"AAAA,SAAQA,IAAI,QAAO,YAAW;AAE9B,SAAQC,oBAAoB,QAAO,mBAAkB;AAErD,SAAQC,mBAAmB,QAAO,2BAA0B;AAE5D;;;;;;;;;;;;;;;CAeC,GACD,OAAO,eAAeC,0BAA0BC,SAAiB;IAC/DF,oBAAoB,oDAAoDE;IAExE,MAAM,EAACC,WAAW,EAAEC,SAAS,EAAEC,WAAW,EAAEC,WAAW,EAAC,GAAG,MAAMP;IAEjEC,oBAAoB,4BAA4BM;IAChDN,oBAAoB,4BAA4BK;IAEhD,MAAME,WAAW,GAAGJ,YAAY,CAAC,EAAED,UAAU,OAAO,CAAC;IACrD,MAAMM,WAAWV,KAAKM,WAAWG;IACjCP,oBAAoB,2BAA2BQ;IAE/C,OAAOA;AACT"}

package/dist/util/telemetry/logger.js

@@ -0,0 +1,59 @@
+import { telemetryStoreDebug } from './telemetryStoreDebug.js';
+import { createTrace } from './trace.js';
+// Process-wide sample rate tracking for log events, shared across all logger instances
+// to deduplicate events regardless of which logger emits them.
+// Use resetLogSampleTracker() in tests to prevent state leaking between test runs.
+const logSampleTracker = new Map();
+/** @public Reset sample rate tracking state. Intended for use in tests only. */ export function resetLogSampleTracker() {
+    logSampleTracker.clear();
+}
+/**
+ * Creates a telemetry logger that emits events via the provided emit function
+ * @internal
+ */ export function createLogger(sessionId, emit) {
+    telemetryStoreDebug('Creating logger for session: %s', sessionId);
+    const log = (event, data)=>{
+        telemetryStoreDebug('Logging event: %s', event.name);
+        // Handle sampling if maxSampleRate is specified
+        if (event.maxSampleRate && event.maxSampleRate > 0) {
+            const now = Date.now();
+            const lastEmit = logSampleTracker.get(event.name) || 0;
+            if (now - lastEmit < event.maxSampleRate) {
+                telemetryStoreDebug('Skipping event %s due to sampling (maxSampleRate: %d)', event.name, event.maxSampleRate);
+                return; // Skip due to sampling
+            }
+            logSampleTracker.set(event.name, now);
+            telemetryStoreDebug('Event %s passed sampling check', event.name);
+        }
+        const logEvent = {
+            createdAt: new Date().toISOString(),
+            data: data ?? null,
+            name: event.name,
+            sessionId,
+            type: 'log',
+            version: event.version
+        };
+        emit(logEvent);
+    };
+    const trace = (event, context)=>{
+        telemetryStoreDebug('Creating trace: %s', event.name);
+        return createTrace(event, context, sessionId, emit, createLogger);
+    };
+    const updateUserProperties = (properties)=>{
+        telemetryStoreDebug('Updating user properties: %o', properties);
+        const userPropsEvent = {
+            createdAt: new Date().toISOString(),
+            properties,
+            sessionId,
+            type: 'userProperties'
+        };
+        emit(userPropsEvent);
+    };
+    return {
+        log,
+        trace,
+        updateUserProperties
+    };
+}
+
+//# sourceMappingURL=logger.js.map

package/dist/util/telemetry/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/logger.ts"],"sourcesContent":["import {\n  type DefinedTelemetryLog,\n  type DefinedTelemetryTrace,\n  type TelemetryEvent,\n  type TelemetryLogger,\n  type TelemetryTrace,\n} from '@sanity/telemetry'\n\nimport {telemetryStoreDebug} from './telemetryStoreDebug.js'\nimport {createTrace} from './trace.js'\n\n// Process-wide sample rate tracking for log events, shared across all logger instances\n// to deduplicate events regardless of which logger emits them.\n// Use resetLogSampleTracker() in tests to prevent state leaking between test runs.\nconst logSampleTracker = new Map<string, number>()\n\n/** @public Reset sample rate tracking state. Intended for use in tests only. */\nexport function resetLogSampleTracker(): void {\n  logSampleTracker.clear()\n}\n\n/**\n * Creates a telemetry logger that emits events via the provided emit function\n * @internal\n */\nexport function createLogger<UserProperties>(\n  sessionId: string,\n  emit: (event: TelemetryEvent) => void,\n): TelemetryLogger<UserProperties> {\n  telemetryStoreDebug('Creating logger for session: %s', sessionId)\n\n  const log = <Data>(event: DefinedTelemetryLog<Data>, data?: Data) => {\n    telemetryStoreDebug('Logging event: %s', event.name)\n\n    // Handle sampling if maxSampleRate is specified\n    if (event.maxSampleRate && event.maxSampleRate > 0) {\n      const now = Date.now()\n      const lastEmit = logSampleTracker.get(event.name) || 0\n\n      if (now - lastEmit < event.maxSampleRate) {\n        telemetryStoreDebug(\n          'Skipping event %s due to sampling (maxSampleRate: %d)',\n          event.name,\n          event.maxSampleRate,\n        )\n        return // Skip due to sampling\n      }\n\n      logSampleTracker.set(event.name, now)\n      telemetryStoreDebug('Event %s passed sampling check', event.name)\n    }\n\n    const logEvent: TelemetryEvent = {\n      createdAt: new Date().toISOString(),\n      data: data ?? null,\n      name: event.name,\n      sessionId,\n      type: 'log',\n      version: event.version,\n    }\n\n    emit(logEvent)\n  }\n\n  const trace = <Data, Context = unknown>(\n    event: DefinedTelemetryTrace<Data, Context>,\n    context?: Context,\n  ): TelemetryTrace<UserProperties, Data> => {\n    telemetryStoreDebug('Creating trace: %s', event.name)\n    return createTrace(event, context, sessionId, emit, createLogger)\n  }\n\n  const updateUserProperties = (properties: UserProperties) => {\n    telemetryStoreDebug('Updating user properties: %o', properties)\n    const userPropsEvent: TelemetryEvent = {\n      createdAt: new Date().toISOString(),\n      properties,\n      sessionId,\n      type: 'userProperties',\n    }\n\n    emit(userPropsEvent)\n  }\n\n  return {\n    log,\n    trace,\n    updateUserProperties,\n  }\n}\n"],"names":["telemetryStoreDebug","createTrace","logSampleTracker","Map","resetLogSampleTracker","clear","createLogger","sessionId","emit","log","event","data","name","maxSampleRate","now","Date","lastEmit","get","set","logEvent","createdAt","toISOString","type","version","trace","context","updateUserProperties","properties","userPropsEvent"],"mappings":"AAQA,SAAQA,mBAAmB,QAAO,2BAA0B;AAC5D,SAAQC,WAAW,QAAO,aAAY;AAEtC,uFAAuF;AACvF,+DAA+D;AAC/D,mFAAmF;AACnF,MAAMC,mBAAmB,IAAIC;AAE7B,8EAA8E,GAC9E,OAAO,SAASC;IACdF,iBAAiBG,KAAK;AACxB;AAEA;;;CAGC,GACD,OAAO,SAASC,aACdC,SAAiB,EACjBC,IAAqC;IAErCR,oBAAoB,mCAAmCO;IAEvD,MAAME,MAAM,CAAOC,OAAkCC;QACnDX,oBAAoB,qBAAqBU,MAAME,IAAI;QAEnD,gDAAgD;QAChD,IAAIF,MAAMG,aAAa,IAAIH,MAAMG,aAAa,GAAG,GAAG;YAClD,MAAMC,MAAMC,KAAKD,GAAG;YACpB,MAAME,WAAWd,iBAAiBe,GAAG,CAACP,MAAME,IAAI,KAAK;YAErD,IAAIE,MAAME,WAAWN,MAAMG,aAAa,EAAE;gBACxCb,oBACE,yDACAU,MAAME,IAAI,EACVF,MAAMG,aAAa;gBAErB,QAAO,uBAAuB;YAChC;YAEAX,iBAAiBgB,GAAG,CAACR,MAAME,IAAI,EAAEE;YACjCd,oBAAoB,kCAAkCU,MAAME,IAAI;QAClE;QAEA,MAAMO,WAA2B;YAC/BC,WAAW,IAAIL,OAAOM,WAAW;YACjCV,MAAMA,QAAQ;YACdC,MAAMF,MAAME,IAAI;YAChBL;YACAe,MAAM;YACNC,SAASb,MAAMa,OAAO;QACxB;QAEAf,KAAKW;IACP;IAEA,MAAMK,QAAQ,CACZd,OACAe;QAEAzB,oBAAoB,sBAAsBU,MAAME,IAAI;QACpD,OAAOX,YAAYS,OAAOe,SAASlB,WAAWC,MAAMF;IACtD;IAEA,MAAMoB,uBAAuB,CAACC;QAC5B3B,oBAAoB,gCAAgC2B;QACpD,MAAMC,iBAAiC;YACrCR,WAAW,IAAIL,OAAOM,WAAW;YACjCM;YACApB;YACAe,MAAM;QACR;QAEAd,KAAKoB;IACP;IAEA,OAAO;QACLnB;QACAe;QACAE;IACF;AACF"}

package/dist/util/telemetry/readNDJSON.js

@@ -0,0 +1,28 @@
+import { readFile } from 'node:fs/promises';
+import { telemetryStoreDebug } from './telemetryStoreDebug.js';
+/**
+ * Reads and parses an NDJSON (newline-delimited JSON) file containing telemetry events.
+ * Malformed lines are skipped individually rather than failing the entire file.
+ *
+ * @param filePath - Path to the NDJSON file
+ * @returns Promise resolving to array of parsed telemetry events
+ *
+ * @internal
+ */ export async function readNDJSON(filePath) {
+    const content = await readFile(filePath, 'utf8');
+    if (!content.trim()) {
+        return [];
+    }
+    const results = [];
+    for (const line of content.trim().split('\n')){
+        if (!line) continue;
+        try {
+            results.push(JSON.parse(line));
+        } catch  {
+            telemetryStoreDebug('Skipping malformed JSON line in %s: %s', filePath, line.slice(0, 100));
+        }
+    }
+    return results;
+}
+
+//# sourceMappingURL=readNDJSON.js.map

package/dist/util/telemetry/readNDJSON.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/readNDJSON.ts"],"sourcesContent":["import {readFile} from 'node:fs/promises'\n\nimport {telemetryStoreDebug} from './telemetryStoreDebug.js'\n\n/**\n * Reads and parses an NDJSON (newline-delimited JSON) file containing telemetry events.\n * Malformed lines are skipped individually rather than failing the entire file.\n *\n * @param filePath - Path to the NDJSON file\n * @returns Promise resolving to array of parsed telemetry events\n *\n * @internal\n */\nexport async function readNDJSON<T>(filePath: string): Promise<T[]> {\n  const content = await readFile(filePath, 'utf8')\n\n  if (!content.trim()) {\n    return []\n  }\n\n  const results: T[] = []\n  for (const line of content.trim().split('\\n')) {\n    if (!line) continue\n    try {\n      results.push(JSON.parse(line) as T)\n    } catch {\n      telemetryStoreDebug('Skipping malformed JSON line in %s: %s', filePath, line.slice(0, 100))\n    }\n  }\n  return results\n}\n"],"names":["readFile","telemetryStoreDebug","readNDJSON","filePath","content","trim","results","line","split","push","JSON","parse","slice"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,SAAQC,mBAAmB,QAAO,2BAA0B;AAE5D;;;;;;;;CAQC,GACD,OAAO,eAAeC,WAAcC,QAAgB;IAClD,MAAMC,UAAU,MAAMJ,SAASG,UAAU;IAEzC,IAAI,CAACC,QAAQC,IAAI,IAAI;QACnB,OAAO,EAAE;IACX;IAEA,MAAMC,UAAe,EAAE;IACvB,KAAK,MAAMC,QAAQH,QAAQC,IAAI,GAAGG,KAAK,CAAC,MAAO;QAC7C,IAAI,CAACD,MAAM;QACX,IAAI;YACFD,QAAQG,IAAI,CAACC,KAAKC,KAAK,CAACJ;QAC1B,EAAE,OAAM;YACNN,oBAAoB,0CAA0CE,UAAUI,KAAKK,KAAK,CAAC,GAAG;QACxF;IACF;IACA,OAAON;AACT"}

package/dist/util/telemetry/telemetryStoreDebug.js

@@ -0,0 +1,7 @@
+import { subdebug } from '@sanity/cli-core';
+/**
+ * Debug logger for telemetry store operations
+ * @internal
+ */ export const telemetryStoreDebug = subdebug('telemetry:telemetryStore');
+
+//# sourceMappingURL=telemetryStoreDebug.js.map

package/dist/util/telemetry/telemetryStoreDebug.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/util/telemetry/telemetryStoreDebug.ts"],"sourcesContent":["import {subdebug} from '@sanity/cli-core'\n\n/**\n * Debug logger for telemetry store operations\n * @internal\n */\nexport const telemetryStoreDebug = subdebug('telemetry:telemetryStore')\n"],"names":["subdebug","telemetryStoreDebug"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC;;;CAGC,GACD,OAAO,MAAMC,sBAAsBD,SAAS,4BAA2B"}

package/dist/util/telemetry/trace.js

@@ -0,0 +1,150 @@
+import { createTraceId } from './createTraceId.js';
+import { telemetryStoreDebug } from './telemetryStoreDebug.js';
+/**
+ * Creates a trace instance that can emit trace lifecycle events
+ * @internal
+ */ export function createTrace(definition, context, sessionId, emit, createLoggerFn) {
+    const traceId = createTraceId();
+    telemetryStoreDebug('Creating trace %s with traceId: %s', definition.name, traceId);
+    let isStarted = false;
+    let isCompleted = false;
+    const emitTraceEvent = (type, data)=>{
+        if (isCompleted) return;
+        const baseEvent = {
+            context: context,
+            createdAt: new Date().toISOString(),
+            name: definition.name,
+            sessionId,
+            traceId,
+            version: definition.version
+        };
+        let traceEvent;
+        switch(type){
+            case 'trace.complete':
+                {
+                    traceEvent = {
+                        ...baseEvent,
+                        type: 'trace.complete',
+                        ...data && {
+                            data
+                        }
+                    };
+                    break;
+                }
+            case 'trace.error':
+                {
+                    traceEvent = {
+                        ...baseEvent,
+                        data,
+                        type: 'trace.error'
+                    };
+                    break;
+                }
+            case 'trace.log':
+                {
+                    traceEvent = {
+                        ...baseEvent,
+                        data,
+                        type: 'trace.log'
+                    };
+                    break;
+                }
+            case 'trace.start':
+                {
+                    traceEvent = {
+                        ...baseEvent,
+                        type: 'trace.start'
+                    };
+                    break;
+                }
+            default:
+                {
+                    return; // Unknown type
+                }
+        }
+        emit(traceEvent);
+    };
+    const start = ()=>{
+        if (isStarted) {
+            telemetryStoreDebug('Trace %s already started', traceId);
+            return;
+        }
+        telemetryStoreDebug('Starting trace %s', traceId);
+        isStarted = true;
+        emitTraceEvent('trace.start');
+    };
+    const log = (data)=>{
+        telemetryStoreDebug('Logging data for trace %s', traceId);
+        if (!isStarted) start();
+        emitTraceEvent('trace.log', data);
+    };
+    const complete = ()=>{
+        if (isCompleted) {
+            telemetryStoreDebug('Trace %s already completed', traceId);
+            return;
+        }
+        telemetryStoreDebug('Completing trace %s', traceId);
+        if (!isStarted) start();
+        emitTraceEvent('trace.complete');
+        isCompleted = true;
+    };
+    const error = (err)=>{
+        if (isCompleted) {
+            telemetryStoreDebug('Trace %s already completed, ignoring error', traceId);
+            return;
+        }
+        telemetryStoreDebug('Error in trace %s: %s', traceId, err.message);
+        if (!isStarted) start();
+        // Convert Error to serializable object
+        const errorData = {
+            message: err.message,
+            name: err.name,
+            stack: err.stack
+        };
+        emitTraceEvent('trace.error', errorData);
+        isCompleted = true;
+    };
+    const awaitPromise = (promise, finalData)=>{
+        if (!isStarted) start();
+        return promise.then((result)=>{
+            if (finalData !== undefined) {
+                log(finalData);
+            }
+            complete();
+            return result;
+        }).catch((err)=>{
+            error(err);
+            throw err;
+        });
+    };
+    const newContext = (name)=>{
+        const contextEmit = (event)=>{
+            // For trace events, we can add context, but for log events we need to be careful
+            if (event.type.startsWith('trace.')) {
+                const existingContext = event.context;
+                emit({
+                    ...event,
+                    context: {
+                        ...typeof existingContext === 'object' && existingContext ? existingContext : {},
+                        contextName: name
+                    }
+                });
+            } else {
+                // For log events, we can't add context as it's not part of TelemetryLogEvent
+                // Just emit as-is
+                emit(event);
+            }
+        };
+        return createLoggerFn(sessionId, contextEmit);
+    };
+    return {
+        await: awaitPromise,
+        complete,
+        error,
+        log,
+        newContext,
+        start
+    };
+}
+
+//# sourceMappingURL=trace.js.map