extension-develop 4.1.31 → 4.1.32

package/dist/846~0.mjs

@@ -0,0 +1,453 @@
+import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import { createRequire, register } from "node:module";
+import { pathToFileURL } from "node:url";
+import dotenv from "dotenv";
+import { isUsingExperimentalConfig as messages_isUsingExperimentalConfig, configUnknownKeys, resolveProjectStructureSync, codedError, configWrongShape, configLoadingError } from "./469~0.mjs";
+import { debugLine, isDebug, CODES } from "./852~0.mjs";
+import { isWebkitBasedBrowser } from "./937~0.mjs";
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_os_4f3c9d58 from "node:os";
+import * as __rspack_external_node_path_806ed179 from "node:path";
+import * as __rspack_external_node_vm_ef240610 from "node:vm";
+const preloadedEnvKeys = new Set();
+function getPreloadedEnvKeys() {
+    return preloadedEnvKeys;
+}
+const ENV_PRELOAD_ORDER = [
+    '.env.defaults',
+    '.env',
+    '.env.local',
+    '.env.development'
+];
+function applyEnvFile(filePath, shellOwned) {
+    const parsed = dotenv.parse(__rspack_external_node_fs_1b05aee1.readFileSync(filePath));
+    for (const [key, value] of Object.entries(parsed))if (!shellOwned.has(key)) {
+        process.env[key] = value;
+        preloadedEnvKeys.add(key);
+    }
+}
+function unwrapDefaultExport(loaded) {
+    if (loaded && 'object' == typeof loaded && 'default' in loaded) return loaded.default;
+    return loaded;
+}
+function loadCommonJsConfigWithStableDirname(absolutePath) {
+    const code = __rspack_external_node_fs_1b05aee1.readFileSync(absolutePath, 'utf-8');
+    const dirname = __rspack_external_node_path_806ed179.dirname(absolutePath);
+    const requireFn = createRequire(absolutePath);
+    const module = {
+        exports: {}
+    };
+    const exports = module.exports;
+    const wrapped = `(function (exports, require, module, __filename, __dirname) {\n${code}\n})`;
+    const fn = new __rspack_external_node_vm_ef240610.Script(wrapped, {
+        filename: absolutePath
+    }).runInThisContext();
+    fn(exports, requireFn, module, absolutePath, dirname);
+    return unwrapDefaultExport(module.exports);
+}
+function findNearestWorkspaceRoot(startDir) {
+    let current = __rspack_external_node_path_806ed179.resolve(startDir);
+    while(true){
+        if (__rspack_external_node_fs_1b05aee1.existsSync(__rspack_external_node_path_806ed179.join(current, 'pnpm-workspace.yaml'))) return current;
+        const parent = __rspack_external_node_path_806ed179.dirname(current);
+        if (parent === current) return;
+        current = parent;
+    }
+}
+function preloadEnvFilesFromDir(envDir) {
+    let loadedAny = false;
+    const shellOwned = new Set(Object.keys(process.env).filter((key)=>!preloadedEnvKeys.has(key)));
+    for (const filename of ENV_PRELOAD_ORDER){
+        const filePath = __rspack_external_node_path_806ed179.join(envDir, filename);
+        if (__rspack_external_node_fs_1b05aee1.existsSync(filePath)) try {
+            applyEnvFile(filePath, shellOwned);
+            loadedAny = true;
+        } catch  {}
+    }
+    return {
+        loadedAny,
+        envDir
+    };
+}
+const PROJECT_CONFIG_FILENAMES = [
+    'extension.config.js',
+    'extension.config.mjs',
+    'extension.config.cjs'
+];
+function configCandidatesIn(dir) {
+    return PROJECT_CONFIG_FILENAMES.map((name)=>__rspack_external_node_path_806ed179.join(dir, name));
+}
+function findConfigFileIn(dir) {
+    return configCandidatesIn(dir).find((p)=>__rspack_external_node_fs_1b05aee1.existsSync(p));
+}
+function resolveManifestDir(projectPath) {
+    try {
+        if (!__rspack_external_node_fs_1b05aee1.statSync(projectPath).isDirectory()) return;
+    } catch  {
+        return;
+    }
+    try {
+        const structure = resolveProjectStructureSync(projectPath, {
+            quiet: true
+        });
+        return __rspack_external_node_path_806ed179.dirname(structure.manifestPath);
+    } catch  {
+        return;
+    }
+}
+function findConfigFile(projectPath) {
+    const atRoot = findConfigFileIn(projectPath);
+    if (atRoot) return atRoot;
+    const manifestDir = resolveManifestDir(projectPath);
+    if (!manifestDir || __rspack_external_node_path_806ed179.resolve(manifestDir) === __rspack_external_node_path_806ed179.resolve(projectPath)) return;
+    return findConfigFileIn(manifestDir);
+}
+function projectConfigCandidatePaths(projectPath) {
+    const dirs = [
+        projectPath
+    ];
+    const manifestDir = resolveManifestDir(projectPath);
+    if (manifestDir && __rspack_external_node_path_806ed179.resolve(manifestDir) !== __rspack_external_node_path_806ed179.resolve(projectPath)) dirs.push(manifestDir);
+    return dirs.flatMap((dir)=>configCandidatesIn(dir));
+}
+function preloadEnvFiles(projectDir) {
+    const local = preloadEnvFilesFromDir(projectDir);
+    if (local.loadedAny) return local;
+    const workspaceRoot = findNearestWorkspaceRoot(projectDir);
+    if (workspaceRoot && workspaceRoot !== projectDir) return preloadEnvFilesFromDir(workspaceRoot);
+    return local;
+}
+const IMPORT_META_ENV_GLOBAL = '__EXTENSION_IMPORT_META_ENV__';
+const IMPORT_META_ENV_HOOK = `
+import {readFileSync} from 'node:fs'
+import {fileURLToPath} from 'node:url'
+
+const CONFIG_FILE = /(^|\\/)extension\\.config\\.(js|mjs)$/
+
+export async function load(url, context, nextLoad) {
+  if (!url.startsWith('file:') || !CONFIG_FILE.test(new URL(url).pathname)) {
+    return nextLoad(url, context)
+  }
+
+  let text
+
+  try {
+    text = readFileSync(fileURLToPath(url), 'utf8')
+  } catch {
+    return nextLoad(url, context)
+  }
+
+  if (!text.includes('import.meta.env')) return nextLoad(url, context)
+
+  // import.meta is module syntax, so the format is settled here. Left to
+  // Node, a package.json without "type" means a reparse and a warning per run.
+  const loaded = await nextLoad(url, {...context, format: 'module'})
+  const source =
+    typeof loaded.source === 'string'
+      ? loaded.source
+      : Buffer.from(loaded.source).toString('utf8')
+
+  return {
+    ...loaded,
+    source: source.replaceAll(
+      'import.meta.env',
+      'globalThis.${IMPORT_META_ENV_GLOBAL}'
+    )
+  }
+}
+`;
+let importMetaEnvHookRegistered = false;
+function prepareImportMetaEnv(absolutePath) {
+    let source = '';
+    try {
+        source = __rspack_external_node_fs_1b05aee1.readFileSync(absolutePath, 'utf-8');
+    } catch  {
+        return;
+    }
+    if (!source.includes('import.meta.env')) return;
+    globalThis[IMPORT_META_ENV_GLOBAL] = Object.freeze({
+        ...process.env
+    });
+    if (importMetaEnvHookRegistered) return;
+    try {
+        register(`data:text/javascript,${encodeURIComponent(IMPORT_META_ENV_HOOK)}`);
+        importMetaEnvHookRegistered = true;
+    } catch  {}
+}
+class ConfigShapeError extends Error {
+    code = CODES.E_CONFIG_LOAD;
+}
+function configLoadError(configPath, cause) {
+    return Object.assign(codedError(CODES.E_CONFIG_LOAD, configLoadingError(configPath, cause)), {
+        cause
+    });
+}
+function isConfigLoadError(error) {
+    return error?.code === CODES.E_CONFIG_LOAD;
+}
+const loadedConfigCache = new Map();
+const reportedConfigPaths = new Set();
+function reportConfigLoadingErrorOnce(configPath, error) {
+    if (isConfigLoadError(error)) return;
+    const key = __rspack_external_node_path_806ed179.resolve(configPath);
+    if (reportedConfigPaths.has(key)) return;
+    reportedConfigPaths.add(key);
+    console.error(configLoadingError(configPath, error));
+}
+const CONFIG_TOP_LEVEL_KEYS = [
+    'browser',
+    'commands',
+    'config',
+    'configResolved',
+    'define',
+    'extensions',
+    'folders',
+    'perfBudgets',
+    'transpilePackages'
+];
+function assertConfigShape(configPath, value) {
+    if (void 0 === value) return;
+    if ('object' != typeof value || null === value || Array.isArray(value)) throw new ConfigShapeError(configWrongShape(configPath, value));
+    const unknown = Object.keys(value).filter((key)=>!CONFIG_TOP_LEVEL_KEYS.includes(key));
+    if (unknown.length > 0) console.error(configUnknownKeys(configPath, unknown, CONFIG_TOP_LEVEL_KEYS));
+}
+async function loadConfigFile(configPath) {
+    const absolutePath = __rspack_external_node_path_806ed179.resolve(configPath);
+    const cached = loadedConfigCache.get(absolutePath);
+    if (cached) return cached;
+    const loading = loadConfigFileUncached(absolutePath).then((value)=>{
+        assertConfigShape(absolutePath, value);
+        return value;
+    });
+    loadedConfigCache.set(absolutePath, loading);
+    try {
+        return await loading;
+    } catch (error) {
+        loadedConfigCache.delete(absolutePath);
+        throw error;
+    }
+}
+async function loadConfigFileUncached(absolutePath) {
+    const projectDir = __rspack_external_node_path_806ed179.dirname(absolutePath);
+    preloadEnvFiles(projectDir);
+    try {
+        if (absolutePath.endsWith('.cjs')) {
+            const requireFn = createRequire(import.meta.url);
+            const required = requireFn(absolutePath);
+            return unwrapDefaultExport(required);
+        }
+        prepareImportMetaEnv(absolutePath);
+        const module = await import(pathToFileURL(absolutePath).href);
+        return unwrapDefaultExport(module);
+    } catch (err) {
+        const error = err;
+        try {
+            if (!absolutePath.endsWith('.mjs')) {
+                const requireFn = createRequire(import.meta.url);
+                let required;
+                try {
+                    required = requireFn(absolutePath);
+                } catch (requireErr) {
+                    const message = String(error?.message || '') + ' ' + String(requireErr?.message || '');
+                    const looksLikeCommonJsInEsm = message.includes('require is not defined in ES module scope') || message.includes('Cannot use import statement outside a module') || message.includes('ERR_REQUIRE_ESM');
+                    if (looksLikeCommonJsInEsm) try {
+                        required = loadCommonJsConfigWithStableDirname(absolutePath);
+                    } catch  {
+                        const tmpDir = __rspack_external_node_fs_1b05aee1.mkdtempSync(__rspack_external_node_path_806ed179.join(__rspack_external_node_os_4f3c9d58.tmpdir(), 'extension-config-'));
+                        try {
+                            const tmpCjsPath = __rspack_external_node_path_806ed179.join(tmpDir, __rspack_external_node_path_806ed179.basename(absolutePath, __rspack_external_node_path_806ed179.extname(absolutePath)) + '.cjs');
+                            __rspack_external_node_fs_1b05aee1.copyFileSync(absolutePath, tmpCjsPath);
+                            required = requireFn(tmpCjsPath);
+                        } finally{
+                            try {
+                                __rspack_external_node_fs_1b05aee1.rmSync(tmpDir, {
+                                    recursive: true,
+                                    force: true
+                                });
+                            } catch  {}
+                        }
+                    }
+                    else throw requireErr;
+                }
+                return unwrapDefaultExport(required);
+            }
+        } catch  {}
+        try {
+            const content = __rspack_external_node_fs_1b05aee1.readFileSync(absolutePath, 'utf-8');
+            return JSON.parse(content);
+        } catch  {
+            throw configLoadError(absolutePath, error);
+        }
+    }
+}
+async function loadCustomConfig(projectPath, context) {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (await isUsingExperimentalConfig(projectPath)) try {
+            const userConfig = await loadConfigFile(configPath);
+            if (userConfig && 'function' == typeof userConfig.config) {
+                const hook = userConfig.config;
+                return (config)=>hook(config, context);
+            }
+            if (userConfig?.config && 'object' == typeof userConfig.config) {
+                const partial = userConfig.config;
+                return (config)=>{
+                    const requireFn = createRequire(import.meta.url);
+                    const { merge } = requireFn('webpack-merge');
+                    return merge(config, partial);
+                };
+            }
+        } catch (err) {
+            const error = err;
+            reportConfigLoadingErrorOnce(configPath, error);
+            throw err;
+        }
+    }
+    return (config)=>config;
+}
+async function loadConfigResolvedHook(projectPath) {
+    const configPath = findConfigFile(projectPath);
+    if (!configPath) return;
+    if (!await isUsingExperimentalConfig(projectPath)) return;
+    const userConfig = await loadConfigFile(configPath);
+    return 'function' == typeof userConfig?.configResolved ? userConfig.configResolved : void 0;
+}
+function typeOfDefineValue(value) {
+    if (null === value) return 'null';
+    if (Array.isArray(value)) return 'unknown[]';
+    switch(typeof value){
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'object':
+            return 'Record<string, unknown>';
+        default:
+            return 'unknown';
+    }
+}
+function collectDefineTypes(into, define) {
+    if (!define || 'object' != typeof define) return;
+    for (const [key, value] of Object.entries(define)){
+        const types = into.get(key) || new Set();
+        types.add(typeOfDefineValue(value));
+        into.set(key, types);
+    }
+}
+async function loadDefineTypes(projectPath) {
+    const configPath = findConfigFile(projectPath);
+    if (!configPath) return {};
+    if (!await isUsingExperimentalConfig(projectPath)) return {};
+    let userConfig;
+    try {
+        userConfig = await loadConfigFile(configPath);
+    } catch  {
+        return {};
+    }
+    const found = new Map();
+    collectDefineTypes(found, userConfig?.define);
+    for (const scope of [
+        userConfig?.browser,
+        userConfig?.commands
+    ])if (scope && 'object' == typeof scope) for (const entry of Object.values(scope))collectDefineTypes(found, entry?.define);
+    const types = {};
+    for (const [key, set] of found)types[key] = [
+        ...set
+    ].sort().join(' | ');
+    return types;
+}
+async function loadProjectConfigDefaults(projectPath) {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (await isUsingExperimentalConfig(projectPath)) try {
+            const userConfig = await loadConfigFile(configPath);
+            return {
+                ...userConfig?.extensions ? {
+                    extensions: userConfig.extensions
+                } : {},
+                ...Array.isArray(userConfig?.transpilePackages) ? {
+                    transpilePackages: userConfig.transpilePackages
+                } : {},
+                ...userConfig?.perfBudgets && 'object' == typeof userConfig.perfBudgets ? {
+                    perfBudgets: userConfig.perfBudgets
+                } : {},
+                ...userConfig?.define && 'object' == typeof userConfig.define ? {
+                    define: userConfig.define
+                } : {},
+                ...userConfig?.folders && 'object' == typeof userConfig.folders ? {
+                    folders: userConfig.folders
+                } : {}
+            };
+        } catch (err) {
+            const error = err;
+            reportConfigLoadingErrorOnce(configPath, error);
+            throw err;
+        }
+    }
+    return {};
+}
+async function loadCommandConfig(projectPath, command) {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (await isUsingExperimentalConfig(projectPath)) try {
+            const userConfig = await loadConfigFile(configPath);
+            return userConfig?.commands?.[command] || {};
+        } catch (err) {
+            const error = err;
+            reportConfigLoadingErrorOnce(configPath, error);
+            throw err;
+        }
+    }
+    return {};
+}
+async function loadBrowserConfig(projectPath, browser = 'chrome') {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (await isUsingExperimentalConfig(projectPath)) try {
+            const userConfig = await loadConfigFile(configPath);
+            if (userConfig?.browser) {
+                const browsers = userConfig.browser;
+                const browserName = String(browser);
+                if ('chromium-based' === browser) {
+                    if (browsers['chromium-based']) return browsers['chromium-based'];
+                    if (browsers.chromium) return browsers.chromium;
+                } else if ('gecko-based' === browser) {
+                    if (browsers['gecko-based']) return browsers['gecko-based'];
+                    if (browsers.firefox) return browsers.firefox;
+                } else if (isWebkitBasedBrowser(browserName)) {
+                    const direct = browsers[browserName];
+                    if (direct) return direct;
+                    if ('safari' !== browserName) {
+                        if (browsers['webkit-based']) return browsers['webkit-based'];
+                        if (browsers.safari) return browsers.safari;
+                    }
+                } else {
+                    const direct = browsers[browserName];
+                    if (direct) return direct;
+                }
+            }
+        } catch (err) {
+            const error = err;
+            reportConfigLoadingErrorOnce(configPath, error);
+            throw err;
+        }
+    }
+    return {
+        browser: browser || 'chrome'
+    };
+}
+let userMessageDelivered = false;
+async function isUsingExperimentalConfig(projectPath) {
+    const configPath = findConfigFile(projectPath);
+    if (configPath) {
+        if (!userMessageDelivered) {
+            if (isDebug()) debugLine(messages_isUsingExperimentalConfig('extension.config.js'));
+            userMessageDelivered = true;
+        }
+        return true;
+    }
+    return false;
+}
+export { findConfigFile, getPreloadedEnvKeys, loadBrowserConfig, loadCommandConfig, loadConfigResolvedHook, loadCustomConfig, loadDefineTypes, loadProjectConfigDefaults, projectConfigCandidatePaths };

package/dist/852~0.mjs

@@ -1,4 +1,5 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
+import { format } from "node:util";
 import pintor from "pintor";
 const GLYPH = '⏵⏵⏵';
 const DEBUG_GLYPH = '···';
@@ -37,13 +38,17 @@ function isMachineOutput() {
     return MACHINE_OUTPUT_VALUES.has(String(process.env.EXTENSION_OUTPUT || '').trim().toLowerCase());
 }
 function humanLine(...parts) {
-    if (isMachineOutput()) return;
+    if (isMachineOutput()) return void process.stderr.write(`${format(...parts)}\n`);
     console.log(...parts);
 }
 function humanWarn(...parts) {
     if (isMachineOutput()) return;
     console.warn(...parts);
 }
+function debugLine(...parts) {
+    if (isMachineOutput()) return void console.error(...parts);
+    console.log(...parts);
+}
 const fmt = {
     heading: (title)=>pintor.underline(pintor.blue(title)),
     label: (key)=>pintor.gray(key.toUpperCase()),
@@ -188,7 +193,6 @@ const CODES = {
     E_CONFIG_LOAD: 'E_CONFIG_LOAD',
     E_MANAGED_DEP_CONFLICT: 'E_MANAGED_DEP_CONFLICT',
     E_TYPES_EMIT: 'E_TYPES_EMIT',
-    E_TSCONFIG_MISSING: 'E_TSCONFIG_MISSING',
     E_OPTIONAL_DEP_UNRESOLVED: 'E_OPTIONAL_DEP_UNRESOLVED',
     E_OPTIONAL_DEP_LOAD: 'E_OPTIONAL_DEP_LOAD',
     E_OPTIONAL_DEP_UNKNOWN: 'E_OPTIONAL_DEP_UNKNOWN',
@@ -204,11 +208,9 @@ const CODES = {
     E_CSS_PARSE: 'E_CSS_PARSE',
     E_CSS_PREPROCESSOR_MISSING: 'E_CSS_PREPROCESSOR_MISSING',
     E_CSS_DEAD_REF: 'E_CSS_DEAD_REF',
-    E_INTEGRATION_INSTALL: 'E_INTEGRATION_INSTALL',
     E_POLYFILL_NOT_FOUND: 'E_POLYFILL_NOT_FOUND',
     E_LOCALES_LAYOUT: 'E_LOCALES_LAYOUT',
     E_WAR_INVALID: 'E_WAR_INVALID',
-    E_MATCH_PATTERN_INVALID: 'E_MATCH_PATTERN_INVALID',
     E_BACKGROUND_REQUIRED: 'E_BACKGROUND_REQUIRED',
     E_CONTENT_SCRIPT_SYNTAX: 'E_CONTENT_SCRIPT_SYNTAX',
     E_NO_ENTRYPOINTS: 'E_NO_ENTRYPOINTS',
@@ -227,7 +229,6 @@ const CODES = {
     E_BROWSER_START_TIMEOUT: 'E_BROWSER_START_TIMEOUT',
     E_LAUNCH_SKIPPED_COMPILE_ERRORS: 'E_LAUNCH_SKIPPED_COMPILE_ERRORS',
     E_INSTANCE_AMBIGUOUS: 'E_INSTANCE_AMBIGUOUS',
-    E_WSL_INTEROP: 'E_WSL_INTEROP',
     E_EXTENSION_LOAD_REFUSED: 'E_EXTENSION_LOAD_REFUSED',
     E_ADDON_INSTALL: 'E_ADDON_INSTALL',
     E_BROWSER_CONNECT: 'E_BROWSER_CONNECT',
@@ -239,6 +240,7 @@ const CODES = {
     E_RDP_PROTOCOL: 'E_RDP_PROTOCOL',
     E_PORT_IN_USE: 'E_PORT_IN_USE',
     E_SESSION_STOPPED: 'E_SESSION_STOPPED',
+    E_SESSION_EXISTS: 'E_SESSION_EXISTS',
     E_LOGS_STREAM_GAP: 'E_LOGS_STREAM_GAP',
     E_BROWSER_INSTALL_PRIVILEGE: 'E_BROWSER_INSTALL_PRIVILEGE',
     E_UNINSTALL_NOOP: 'E_UNINSTALL_NOOP'
@@ -292,4 +294,4 @@ const ENVELOPE = {
         }, extras);
     }
 };
-export { CODES, ENVELOPE, artifactNoun, browserRowValue, card, claimCardKey, fmt, hasChannelPrefix, humanLine, humanWarn, isDebug, isMachineOutput, prefix, stripChannelPrefix };
+export { CODES, ENVELOPE, artifactNoun, browserRowValue, card, claimCardKey, debugLine, fmt, hasChannelPrefix, humanLine, humanWarn, isDebug, isMachineOutput, prefix, stripChannelPrefix };

package/dist/bridge.mjs

@@ -1,7 +1,8 @@
 import { createRequire as __extjsCreateRequire } from "node:module"; const require = __extjsCreateRequire(import.meta.url);
 import { WebSocket } from "ws";
-import { logsPath, resolveProjectStructureSync, readyContractPath, getDirs } from "./896~0.mjs";
+import { readyContractPath, logsPath } from "./771~0.mjs";
 import { CONTROL_WS_PATH, LOG_CONTEXTS } from "./616~0.mjs";
+import { resolveProjectStructureSync, getDirs } from "./469~0.mjs";
 import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
 import * as __rspack_external_node_path_806ed179 from "node:path";
 function readReadyContractDocument(projectPath, browser = 'chrome') {
@@ -417,5 +418,5 @@ var bridge_entry_CLOSE_SLOW_CONSUMER = 4008;
 var bridge_entry_CONTROL_ENVELOPE_VERSION = 1;
 var bridge_entry_LOG_EVENT_VERSION = 1;
 export { CONTROL_WS_PATH, LOG_CONTEXTS, REFUSAL_API_UNAVAILABLE, REFUSAL_NEEDS_HEADED_WINDOW, REFUSAL_NEEDS_USER_GESTURE, REFUSAL_SURFACE_NOT_OPEN, REFUSAL_TAB_NOT_FOUND, REFUSAL_URL_REFUSED, readControlToken, readPersistedControlPort } from "./616~0.mjs";
-export { actionsPath, browserArtifactsDir, browserDistDir, browserProfileRootDir, buildSummaryPath, controlPortFilePath, controlTokenPath, eventsPath, logsPath, readyContractPath, sessionArtifactsRootDir, sessionStateDir } from "./896~0.mjs";
+export { actionsPath, browserArtifactsDir, browserDistDir, browserProfileRootDir, buildSummaryPath, controlPortFilePath, controlTokenPath, eventsPath, logsPath, readyContractPath, sessionArtifactsRootDir, sessionStateDir } from "./771~0.mjs";
 export { BridgeConsumer, BridgeController, LOG_LEVEL_FILTERS, LOG_LEVEL_ORDER, bridge_entry_CLOSE_BAD_HELLO as CLOSE_BAD_HELLO, bridge_entry_CLOSE_BAD_INSTANCE as CLOSE_BAD_INSTANCE, bridge_entry_CLOSE_CONTROL_UNAVAILABLE as CLOSE_CONTROL_UNAVAILABLE, bridge_entry_CLOSE_SLOW_CONSUMER as CLOSE_SLOW_CONSUMER, bridge_entry_CONTROL_ENVELOPE_VERSION as CONTROL_ENVELOPE_VERSION, bridge_entry_LOG_EVENT_VERSION as LOG_EVENT_VERSION, isAfterSince, logLevelRank, logQueryProblem, matchesLogQuery, parseLogLevelFilter, parseLogSince, readLogEvents, readReadyContract, readReadyContractDocument, resolveSessionProjectRoot, unknownLogContexts };

package/dist/command-preview.d.ts

@@ -11,6 +11,7 @@ export interface ResolvedPreviewOptions {
     extensionsToLoad: string[];
     noOpen?: boolean;
     profile?: string | false;
+    profileSource?: 'flag' | 'config';
     persistProfile?: boolean;
     preferences?: Record<string, unknown>;
     browserFlags?: string[];