@@ -21722,21 +21722,143 @@ const installImprove = (modules) => {
 			}
 		}
 		if (index === -1) return;
-		const merged = A.optimize(
-			makeNode(A.ConditionalNode, self, {
-				test: self.test,
-				consequent: first[index].argument,
-				alternate: second[index].argument
-			}),
-			compressor
-		);
+		// Optimized here, it would read the context of the conditional it replaces.
+		const merged = makeNode(A.ConditionalNode, self, {
+			test: self.test,
+			consequent: first[index].argument,
+			alternate: second[index].argument
+		});
 		const call = A.cloneNode(/** @type {Node} */ (consequent));
 		const spread = A.cloneNode(first[index]);
 		spread.argument = merged;
 		call.arguments[index] = spread;
 		return call;
 	};
 
+	/**
+	 * Whether a name's binding is one no code run elsewhere can rebind or see:
+	 * its own function's, every reference in that function, and no `eval`.
+	 * @param {Node} node a name read
+	 * @param {Compressor} compressor the compressor
+	 * @returns {boolean} true when it is
+	 */
+	const readsOwnLocal = (node, compressor) => {
+		const definition = node.definition;
+		if (
+			!definition ||
+			definition.global ||
+			definition.scope.isPinned() ||
+			!readsAlike(node, compressor)
+		) {
+			return false;
+		}
+		const functionScope = definition.scope.getDefunScope();
+		return definition.references.every(
+			(/** @type {Node} */ reference) =>
+				reference.scope.getDefunScope() === functionScope
+		);
+	};
+
+	/**
+	 * Whether reading a callee before a conditional's test, not after, runs
+	 * alike: a function or `var` nothing writes, or, where the test reads only
+	 * its own function's names and runs nothing, any name or member path.
+	 * @param {Node} callee the callee both calls share
+	 * @param {Node} test the conditional's test
+	 * @param {Compressor} compressor the compressor
+	 * @returns {boolean} true when it does
+	 */
+	const readsCalleeAside = (callee, test, compressor) => {
+		if (A.isSymbolRefNode(callee) && callee.definition) {
+			const definition = callee.definition;
+			const declared = definition.identifiers[0];
+			if (
+				compressor.option("reduce_vars") &&
+				readsAlike(callee, compressor) &&
+				(A.isSymbolDefunNode(declared) ||
+					A.isSymbolVarNode(declared) ||
+					A.isSymbolFunargNode(declared)) &&
+				!definition.assignments &&
+				!definition.patternWrites &&
+				definition.fixed
+			) {
+				return true;
+			}
+		}
+		let path = callee;
+		while (A.isPropAccessNode(path) && !path.optional) {
+			if (A.isSubNode(path) && !A.isConstantNode(path.property)) return false;
+			path = path.object;
+		}
+		if (!A.isSymbolRefNode(path) && !A.isThisNode(path)) return false;
+		if (A.hasSideEffects(test, compressor)) return false;
+		let ownLocals = true;
+		walkNode(
+			test,
+			A.createWalker((/** @type {Node} */ node) => {
+				if (!ownLocals) return true;
+				if (A.isLambdaNode(node)) return (ownLocals = false);
+				if (A.isSymbolRefNode(node) && !readsOwnLocal(node, compressor)) {
+					ownLocals = false;
+				}
+				return undefined;
+			})
+		);
+		return ownLocals;
+	};
+
+	/**
+	 * `a ? o.f(b) : o.f(c)` as `o.f(a ? b : c)`, which terser keeps where the
+	 * callee may run code, that here neither sees nor changes what the test reads.
+	 * @param {Node} self a conditional
+	 * @param {Compressor} compressor the compressor
+	 * @returns {Node | undefined} the call, none where reading it first may differ
+	 */
+	const mergedCall = (self, compressor) => {
+		const { consequent, alternate } = self;
+		if (
+			!A.isCallNode(consequent) ||
+			A.kindOf(alternate) !== A.kindOf(/** @type {Node} */ (consequent)) ||
+			/** @type {Node} */ (consequent).optional ||
+			alternate.optional ||
+			/** @type {Node} */ (consequent).arguments.length !==
+				alternate.arguments.length ||
+			!A.isEquivalent(/** @type {Node} */ (consequent).callee, alternate.callee)
+		) {
+			return;
+		}
+		const first = /** @type {Node} */ (consequent).arguments;
+		const second = alternate.arguments;
+		let index = -1;
+		for (let i = 0; i < first.length; i++) {
+			if (A.isExpansionNode(first[i]) || A.isExpansionNode(second[i])) return;
+			if (!A.isEquivalent(first[i], second[i])) {
+				if (index !== -1) return;
+				index = i;
+			} else if (index === -1 && !A.isConstantNode(first[i])) {
+				// It ran after the test, and now runs before it.
+				return;
+			}
+		}
+		if (
+			index === -1 ||
+			!readsCalleeAside(
+				/** @type {Node} */ (consequent).callee,
+				self.test,
+				compressor
+			)
+		) {
+			return;
+		}
+		const call = A.cloneNode(/** @type {Node} */ (consequent));
+		call.arguments[index] = makeNode(A.ConditionalNode, self, {
+			test: self.test,
+			consequent: first[index],
+			alternate: second[index]
+		});
+		return call;
+	};
+
 	A.wrapOptimizer(
 		"Conditional",
 		(optimizeConditional) => (self, compressor) => {
@@ -21745,7 +21867,8 @@ const installImprove = (modules) => {
 				(improvements.enabled &&
 					A.isConditionalNode(optimized) &&
 					compressor.option("conditionals") &&
-					mergedSpreadCall(optimized, compressor)) ||
+					(mergedSpreadCall(optimized, compressor) ||
+						mergedCall(optimized, compressor))) ||
 				optimized
 			);
 		}
@@ -26502,12 +26625,14 @@ const installImprove = (modules) => {
 
 	/**
 	 * `null != a && a.b()` and `null == a || a.b()` as `a?.b()` where nothing
-	 * reads the value, which the chain gives as `undefined` in place of a boolean.
+	 * reads the value, which the chain gives as `undefined` in place of a boolean,
+	 * and `null != a && a.b` where only its truth is read.
 	 * @param {Node} node a logical expression
+	 * @param {Node} self the node visited, whose context the compressor knows
 	 * @param {Compressor} compressor the compressor
 	 * @returns {Node | undefined} the optional chain, or undefined
 	 */
-	const unreadOptionalChain = (node, compressor) => {
+	const unreadOptionalChain = (node, self, compressor) => {
 		const { operator, left, right } = node;
 		const parent = compressor.parent();
 		if (
@@ -26518,7 +26643,11 @@ const installImprove = (modules) => {
 			) ||
 			!(
 				(A.isSimpleStatementNode(parent) && parent.expression === node) ||
-				(A.isSequenceNode(parent) && A.tailNode(parent) !== node)
+				(A.isSequenceNode(parent) && A.tailNode(parent) !== node) ||
+				// `false` and `undefined` are alike falsy, while `||` would read `true`.
+				(operator === "&&" &&
+					compressor.self() === self &&
+					compressor.in_boolean_context())
 			)
 		) {
 			return undefined;
@@ -28638,7 +28767,7 @@ const installImprove = (modules) => {
 			booleanEquality(optimized, compressor) ||
 			commutedProduct(optimized, compressor) ||
 			logicalAssignment(optimized, compressor) ||
-			unreadOptionalChain(optimized, compressor) ||
+			unreadOptionalChain(optimized, self, compressor) ||
 			coerceBinary(optimized, self, compressor) ||
 			shortenBinary(optimized, compressor)
 		);
@@ -28774,6 +28903,9 @@ const installImprove = (modules) => {
 		// A name the compressor wrote without a definition counts by its name.
 		/** @type {Set<Definition | string>} */
 		const written = new Set();
+		// `export { x }` names a binding away from its declaration.
+		/** @type {Set<Definition>} */
+		const exported = new Set();
 		/**
 		 * @param {Node | null} target what an assignment, update or loop writes
 		 * @returns {void}
@@ -28840,6 +28972,16 @@ const installImprove = (modules) => {
 				case "ForOfStatement":
 					if (!A.isDefinitionsNode(node.left)) markWritten(node.left);
 					break;
+				case "ExportNamedDeclaration":
+				case "ExportDefaultDeclaration":
+					if (node.source) break;
+					for (const name of node.exported_names || []) {
+						if (name.local.definition) exported.add(name.local.definition);
+					}
+					if (node.exported_value && node.exported_value.definition) {
+						exported.add(node.exported_value.definition);
+					}
+					break;
 				default:
 					if (join && (node[KIND_BITS] & KIND_BLOCK) !== 0) {
 						blocks.push(node);
@@ -28860,6 +29002,7 @@ const installImprove = (modules) => {
 					symbol !== undefined &&
 					symbol !== null &&
 					(toplevelPrivate || !A.isToplevelNode(symbol.scope.node)) &&
+					!exported.has(symbol) &&
 					!symbol.scope.isPinned() &&
 					!written.has(symbol) &&
 					!written.has(node.name);
 
@@ -245,6 +245,30 @@ const IMPROVED_CASES = [
 		{ compress: {}, mangle: false },
 		'function y(){console.log("y")}var z=2;console.log((y(),1),z,(y(),y(),3));'
 	],
+	[
+		"`null != a && a.b` where only its truth is read, as `a?.b`, which is `undefined` where `a` is nullish",
+		'function f(n) { if (null != n && n.length) return "x"; return !(null != n && n.a) ? "y" : "z"; } console.log(f(), f(null), f([1]), f({ a: 1 }), f({}));',
+		{ compress: { ecma: 2020 }, mangle: false },
+		'function f(n){return n?.length?"x":n?.a?"z":"y"}console.log(f(),f(null),f([1]),f({a:1}),f({}));'
+	],
+	[
+		"two calls through one member path differing in one argument, where the test reads only names nothing else can see",
+		"function f(i, n) { return 0 !== i ? Math.abs(i) : Math.abs(n); } function g(t, x) { var set = function () { t = 0; }; return t ? x.m(1, set) : x.m(2, set); } var o = { m: function (v) { return v; } }; console.log(f(-1, -2), f(0, -3), g(1, o), g(0, o));",
+		{ compress: {}, mangle: false },
+		"function f(i,n){return Math.abs(0!==i?i:n)}function g(t,x){var set=function(){t=0};return t?x.m(1,set):x.m(2,set)}var o={m:function(v){return v}};console.log(f(-1,-2),f(0,-3),g(1,o),g(0,o));"
+	],
+	[
+		"two calls spreading a string or another iterable, merged in a statement that reads no truth",
+		'function f(c, b) { c ? g(..."ab") : g(...b); } function g(v, w) { console.log(v, w); } f(1, ["y"]); f(0, ["y"]);',
+		{ compress: {}, mangle: false },
+		'function f(c,b){g(...c?"ab":b)}function g(v,w){console.log(v,w)}f(1,["y"]),f(0,["y"]);'
+	],
+	[
+		"two calls through one member path, merged in a statement that reads no truth",
+		'function g(n) { if (!(n < 0)) console.log(typeof []); else console.log("y"); } g(-1); g(1);',
+		{ compress: {}, mangle: false },
+		'function g(n){console.log(n<0?"y":"object")}g(-1),g(1);'
+	],
 	[
 		"a new object compared with a primitive, another new object or `null`, which it never equals (terser#1335)",
 		'console.log({ a: 7 } === null, [] !== 1, (() => 1) == null, {} != null, {} == "[object Object]");',
@@ -303,7 +327,7 @@ const IMPROVED_CASES = [
 		"a `switch` every branch of which runs one expression and leaves",
 		'var log = []; function f(a) { switch (a) { case 1: log.push("one"); break; case 2: log.push("two"); break; default: log.push("x"); } } f(1); f(2); f(3); console.log(log.join());',
 		{ compress: {}, mangle: false },
-		'var log=[];function f(a){1===a?log.push("one"):2===a?log.push("two"):log.push("x")}f(1),f(2),f(3),console.log(log.join());'
+		'var log=[];function f(a){log.push(1===a?"one":2===a?"two":"x")}f(1),f(2),f(3),console.log(log.join());'
 	],
 	[
 		"a `switch` running one expression per branch, with no default",
@@ -8645,6 +8669,17 @@ describe("syntax-printer", () => {
 			});
 		}
 
+		it("should keep a module's exported `const` while writing its private ones as `let`", async () => {
+			const { minify } = await load();
+			const { code } = await minify(
+				"const x = { a: 1 }; console.log(x); const z = { b: 2 }; console.log(z, z); export { x };",
+				{ module: true, mangle: false }
+			);
+			expect(code).toBe(
+				"const x={a:1};console.log(x);let z={b:2};console.log(z,z);export{x};"
+			);
+		});
+
 		it("should name a module's imports and exports by the names they spell, where that writes less", async () => {
 			const { minify, improvements } = await load();
 			/** @type {[string, string][]} */