@apifuse/provider-sdk 2.2.0-beta.40 → 2.2.0-beta.42

package/bin/apifuse-submit-check.ts

@@ -4,10 +4,11 @@ import { type ChildProcess, spawn } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { writeFile } from "node:fs/promises";
 import { createServer } from "node:net";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 
 import * as acorn from "acorn";
+import type TS from "typescript";
 import { z } from "zod";
 
 import packageJson from "../package.json";
@@ -28,6 +29,19 @@ import { type CheckResult, PROMPT_ASSETS_CHECK_MESSAGE, runChecks } from "./apif
 import { hasSubstantiveDelimitedTextStructure } from "./submit-check-delimited-text.js";
 import { hasSubstantiveXmlStructure } from "./submit-check-xml.js";
 
+const ts: typeof import("typescript") = await loadTypeScript();
+
+async function loadTypeScript(): Promise<typeof import("typescript")> {
+	try {
+		return await import("typescript");
+	} catch {
+		console.error(
+			"apifuse submit-check requires typescript; install it in the workspace running the CLI (bun add -d typescript)",
+		);
+		process.exit(1);
+	}
+}
+
 const TIERS = ["bronze", "silver", "gold", "diamond"] as const;
 const TIER_VALUES: ReadonlySet<string> = new Set(TIERS);
 type BountyTier = (typeof TIERS)[number];
@@ -112,11 +126,14 @@ export type SmokeResult = {
 type SourceFinding = {
 	file: string;
 	line: number;
+	detail?: string;
 };
 
 const SDK_NATIVE_CATEGORY = "sdk-native";
 const VENDOR_SHIM_PROVIDER_ID_PREFIX = "apifuse-provider-";
 const MAX_SOURCE_FINDING_EVIDENCE = 5;
+const MAX_LOAD_ERROR_EVIDENCE = 5;
+const MAX_LOAD_ERROR_MESSAGE_LENGTH = 500;
 
 const CATEGORY_MAX_POINTS = {
 	definition: 15,
@@ -271,7 +288,20 @@ export async function buildSubmitCheckReport(
 ): Promise<SubmitCheckReport> {
 	const checks: SubmitCheck[] = [];
 	const baseChecks = await safeRunChecks(providerRoot);
-	const provider = await safeLoadProvider(providerRoot);
+	const loadResult = await safeLoadProvider(providerRoot);
+	const provider = loadResult.ok ? loadResult.provider : undefined;
+	let indexParseError: string | undefined;
+	if (!provider) {
+		const indexPath = resolve(providerRoot, "index.ts");
+		if (existsSync(indexPath)) {
+			const relPath = toRelativeProviderPath(providerRoot, indexPath);
+			try {
+				maskCommentsAndStrings(readFileSync(indexPath, "utf8"), relPath);
+			} catch (error) {
+				indexParseError = error instanceof Error ? error.message : String(error);
+			}
+		}
+	}
 
 	// Prompt-asset freshness is reported by its own dedicated zero-point
 	// blocker below; filter the base-check duplicate so it is not double
@@ -282,17 +312,20 @@ export async function buildSubmitCheckReport(
 		),
 	);
 	checks.push(scorePromptAssetFreshness(providerRoot));
-	checks.push(scoreProviderIdSlug(providerRoot, provider));
-	checks.push(scoreNoVendorShim(providerRoot));
-	checks.push(scoreNoVendorImport(providerRoot));
-	checks.push(scoreDescribeKey(providerRoot));
-	checks.push(scoreNoRawFetch(providerRoot));
-	checks.push(scoreNoRedundantRuntimeGuards(providerRoot));
-	checks.push(scoreManagedBrowserRuntime(providerRoot));
-	checks.push(scoreAsAssertionCount(providerRoot));
-	checks.push(scoreUnsafeInputPassthrough(providerRoot));
-	checks.push(scoreUnjustifiedLooseSchema(providerRoot));
-	checks.push(scoreFlatOperationComposition(providerRoot));
+	if (!indexParseError) {
+		checks.push(scoreProviderIdSlug(providerRoot, provider));
+		checks.push(scoreNoVendorShim(providerRoot));
+		checks.push(scoreNoVendorImport(providerRoot));
+		checks.push(scoreDescribeKey(providerRoot));
+		checks.push(scoreNoRawFetch(providerRoot));
+		checks.push(scoreNoDynamicCode(providerRoot));
+		checks.push(scoreNoRedundantRuntimeGuards(providerRoot));
+		checks.push(scoreManagedBrowserRuntime(providerRoot));
+		checks.push(scoreAsAssertionCount(providerRoot));
+		checks.push(scoreUnsafeInputPassthrough(providerRoot));
+		checks.push(scoreUnjustifiedLooseSchema(providerRoot));
+		checks.push(scoreFlatOperationComposition(providerRoot));
+	}
 
 	if (provider) {
 		const smokeResult = args.smoke ? await runSubmitCheckSmoke(providerRoot, provider) : undefined;
@@ -311,15 +344,38 @@ export async function buildSubmitCheckReport(
 		checks.push(scoreRepositoryDx(providerRoot));
 		checks.push(scoreSecrets(providerRoot, provider));
 	} else {
+		const loadEvidence = indexParseError
+			? undefined
+			: loadResult.ok
+				? undefined
+				: formatLoadErrorEvidence(loadResult.error, providerRoot);
+		const loadRemediation = indexParseError
+			? "Fix the syntax error reported by the provider-load-parse blocker before apifuse check can load the provider."
+			: !loadResult.ok
+				? "Fix the import/initialization failure shown in evidence so apifuse check can load the provider."
+				: "Fix index.ts so it default-exports defineProvider(...).";
 		checks.push(
 			blocker(
 				"provider-load",
 				"definition",
 				"Provider could not be loaded.",
-				"Fix index.ts so it default-exports defineProvider(...).",
+				loadRemediation,
 				CATEGORY_MAX_POINTS.definition,
+				loadEvidence,
 			),
 		);
+		if (indexParseError) {
+			checks.push(
+				blocker(
+					"provider-load-parse",
+					"definition",
+					"Provider index.ts could not be parsed safely.",
+					"Fix the syntax error in index.ts before submitting.",
+					0,
+					[indexParseError],
+				),
+			);
+		}
 	}
 
 	const total = clamp(Math.round(checks.reduce((sum, check) => sum + check.points, 0)), 0, 100);
@@ -447,7 +503,7 @@ function scoreDescribeKey(providerRoot: string): SubmitCheck {
 }
 
 function scoreNoRawFetch(providerRoot: string): SubmitCheck {
-	const findings = findSourceLineMatches(providerRoot, /(?<![.\w])fetch\s*\(/);
+	const findings = findGlobalSinkCalls(providerRoot, FETCH_SINKS);
 	if (findings.length > 0) {
 		const evidence = formatSourceFindings(findings);
 		return blocker(
@@ -463,6 +519,435 @@ function scoreNoRawFetch(providerRoot: string): SubmitCheck {
 	return pass("no-raw-fetch", SDK_NATIVE_CATEGORY, "Provider source avoids raw fetch().", 0);
 }
 
+const DYNAMIC_CODE_SINKS: ReadonlySet<string> = new Set(["eval", "Function"]);
+const FETCH_SINKS: ReadonlySet<string> = new Set(["fetch"]);
+const DYNAMIC_CODE_GLOBAL_OBJECTS: ReadonlySet<string> = new Set([
+	"globalThis",
+	"window",
+	"self",
+	"global",
+]);
+
+function unwrapLocalExpression(expression: TS.Expression): TS.Expression {
+	let current = expression;
+	while (
+		ts.isParenthesizedExpression(current) ||
+		ts.isAsExpression(current) ||
+		ts.isSatisfiesExpression(current) ||
+		ts.isNonNullExpression(current)
+	) {
+		current = current.expression;
+	}
+	if (ts.isBinaryExpression(current) && current.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+		return unwrapLocalExpression(current.right);
+	}
+	return current;
+}
+
+type LocalBinding = {
+	declaration: TS.Identifier;
+	initializer?: TS.Expression;
+	destructuredProperty?: string;
+	mutable: boolean;
+	reassigned: boolean;
+};
+
+type LocalBindings = {
+	scopes: Map<TS.Node, Map<string, LocalBinding[]>>;
+};
+
+function isLexicalScope(node: TS.Node): boolean {
+	return (
+		ts.isSourceFile(node) ||
+		ts.isFunctionLike(node) ||
+		ts.isBlock(node) ||
+		ts.isModuleBlock(node) ||
+		ts.isCaseBlock(node) ||
+		ts.isCatchClause(node) ||
+		ts.isForStatement(node) ||
+		ts.isForInStatement(node) ||
+		ts.isForOfStatement(node)
+	);
+}
+
+function enclosingScope(node: TS.Node, functionScoped: boolean): TS.Node {
+	let current: TS.Node | undefined = node.parent;
+	while (current !== undefined) {
+		if (
+			ts.isSourceFile(current) ||
+			(functionScoped ? ts.isFunctionLike(current) : isLexicalScope(current))
+		) {
+			return current;
+		}
+		current = current.parent;
+	}
+	return node.getSourceFile();
+}
+
+function collectLocalBindings(sourceFile: TS.SourceFile): LocalBindings {
+	const bindings: LocalBindings = { scopes: new Map() };
+	const addBinding = (
+		scope: TS.Node,
+		name: TS.Identifier,
+		binding: Omit<LocalBinding, "declaration" | "reassigned">,
+	): void => {
+		let scopeBindings = bindings.scopes.get(scope);
+		if (scopeBindings === undefined) {
+			scopeBindings = new Map();
+			bindings.scopes.set(scope, scopeBindings);
+		}
+		const existing = scopeBindings.get(name.text);
+		const localBinding: LocalBinding = { ...binding, declaration: name, reassigned: false };
+		if (existing === undefined) {
+			scopeBindings.set(name.text, [localBinding]);
+		} else {
+			existing.push(localBinding);
+		}
+	};
+	const addBindingName = (
+		bindingName: TS.BindingName,
+		scope: TS.Node,
+		binding: Omit<LocalBinding, "declaration" | "reassigned">,
+	): void => {
+		if (ts.isIdentifier(bindingName)) {
+			addBinding(scope, bindingName, binding);
+			return;
+		}
+		for (const element of bindingName.elements) {
+			if (ts.isOmittedExpression(element)) {
+				continue;
+			}
+			if (ts.isObjectBindingPattern(bindingName) && !element.dotDotDotToken) {
+				const property = element.propertyName ?? element.name;
+				const propertyName = propertyNameText(property);
+				if (propertyName !== undefined && ts.isIdentifier(element.name)) {
+					addBinding(scope, element.name, {
+						initializer: binding.initializer,
+						destructuredProperty: propertyName,
+						mutable: binding.mutable,
+					});
+					continue;
+				}
+			}
+			addBindingName(element.name, scope, { mutable: binding.mutable });
+		}
+	};
+	const visit = (node: TS.Node): void => {
+		if (ts.isVariableDeclaration(node)) {
+			const declarationList = ts.isVariableDeclarationList(node.parent) ? node.parent : undefined;
+			const isConstBinding =
+				declarationList !== undefined && (declarationList.flags & ts.NodeFlags.Const) !== 0;
+			const isBlockScoped =
+				declarationList !== undefined && (declarationList.flags & ts.NodeFlags.BlockScoped) !== 0;
+			addBindingName(node.name, enclosingScope(node, !isBlockScoped), {
+				initializer: node.initializer,
+				mutable: !isConstBinding,
+			});
+		} else if (ts.isFunctionDeclaration(node) && node.name !== undefined) {
+			addBinding(enclosingScope(node, false), node.name, { mutable: false });
+		} else if (ts.isFunctionExpression(node) && node.name !== undefined) {
+			addBinding(node, node.name, { mutable: false });
+		} else if (ts.isClassDeclaration(node) && node.name !== undefined) {
+			addBinding(enclosingScope(node, false), node.name, { mutable: false });
+		} else if (ts.isClassExpression(node) && node.name !== undefined) {
+			addBinding(node, node.name, { mutable: false });
+		} else if (ts.isParameter(node)) {
+			addBindingName(node.name, enclosingScope(node, true), { mutable: true });
+		} else if (ts.isImportClause(node) && node.name !== undefined) {
+			addBinding(sourceFile, node.name, { mutable: false });
+		} else if (ts.isNamespaceImport(node) || ts.isImportSpecifier(node)) {
+			addBinding(sourceFile, node.name, { mutable: false });
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+
+	const markReassigned = (identifier: TS.Identifier): void => {
+		for (const binding of lookupLocalBindings(identifier, bindings) ?? []) {
+			binding.reassigned = true;
+		}
+	};
+	const markAssignmentTarget = (node: TS.Node): void => {
+		const target = ts.isExpression(node) ? unwrapLocalExpression(node) : node;
+		if (ts.isIdentifier(target)) {
+			markReassigned(target);
+			return;
+		}
+		if (ts.isObjectLiteralExpression(target)) {
+			for (const element of target.properties) {
+				if (ts.isSpreadAssignment(element)) {
+					markAssignmentTarget(element.expression);
+				} else if (ts.isPropertyAssignment(element)) {
+					markAssignmentTarget(element.initializer);
+				} else if (ts.isShorthandPropertyAssignment(element)) {
+					markAssignmentTarget(element.name);
+				}
+			}
+		} else if (ts.isArrayLiteralExpression(target)) {
+			for (const element of target.elements) {
+				if (!ts.isOmittedExpression(element)) {
+					markAssignmentTarget(ts.isSpreadElement(element) ? element.expression : element);
+				}
+			}
+		}
+	};
+	const visitAssignments = (node: TS.Node): void => {
+		if (
+			ts.isBinaryExpression(node) &&
+			node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+			node.operatorToken.kind <= ts.SyntaxKind.LastAssignment
+		) {
+			markAssignmentTarget(node.left);
+		} else if (
+			(ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+			(node.operator === ts.SyntaxKind.PlusPlusToken ||
+				node.operator === ts.SyntaxKind.MinusMinusToken)
+		) {
+			markAssignmentTarget(node.operand);
+		} else if (
+			(ts.isForInStatement(node) || ts.isForOfStatement(node)) &&
+			!ts.isVariableDeclarationList(node.initializer)
+		) {
+			markAssignmentTarget(node.initializer);
+		}
+		ts.forEachChild(node, visitAssignments);
+	};
+	visitAssignments(sourceFile);
+	return bindings;
+}
+
+function lookupLocalBindings(
+	reference: TS.Identifier,
+	bindings: LocalBindings,
+): readonly LocalBinding[] | undefined {
+	let current: TS.Node | undefined = reference;
+	while (current !== undefined) {
+		const localBindings = bindings.scopes.get(current)?.get(reference.text);
+		if (localBindings !== undefined && localBindings.length > 0) {
+			return localBindings;
+		}
+		current = current.parent;
+	}
+	return undefined;
+}
+
+function propertyNameText(name: TS.PropertyName | TS.BindingName): string | undefined {
+	if (
+		ts.isIdentifier(name) ||
+		ts.isStringLiteral(name) ||
+		ts.isNumericLiteral(name) ||
+		ts.isNoSubstitutionTemplateLiteral(name)
+	) {
+		return name.text;
+	}
+	if (ts.isComputedPropertyName(name)) {
+		const expression = unwrapLocalExpression(name.expression);
+		if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+			return expression.text;
+		}
+	}
+	return undefined;
+}
+
+function isUnshadowedGlobalObject(reference: TS.Expression, bindings: LocalBindings): boolean {
+	const receiver = unwrapLocalExpression(reference);
+	return (
+		ts.isIdentifier(receiver) &&
+		DYNAMIC_CODE_GLOBAL_OBJECTS.has(receiver.text) &&
+		lookupLocalBindings(receiver, bindings) === undefined
+	);
+}
+
+function isGlobalMemberSink(
+	expression: TS.Expression,
+	sinkNames: ReadonlySet<string>,
+	bindings: LocalBindings,
+): boolean {
+	const callee = unwrapLocalExpression(expression);
+	let sinkName: string | undefined;
+	let receiver: TS.Expression | undefined;
+	if (ts.isPropertyAccessExpression(callee)) {
+		sinkName = callee.name.text;
+		receiver = callee.expression;
+	} else if (ts.isElementAccessExpression(callee)) {
+		const argument = callee.argumentExpression;
+		if (
+			argument !== undefined &&
+			(ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument))
+		) {
+			sinkName = argument.text;
+			receiver = callee.expression;
+		}
+	}
+	if (sinkName === undefined || receiver === undefined || !sinkNames.has(sinkName)) {
+		return false;
+	}
+	return isUnshadowedGlobalObject(receiver, bindings);
+}
+
+function isGlobalSinkReference(
+	expression: TS.Expression,
+	sinkNames: ReadonlySet<string>,
+	bindings: LocalBindings,
+	resolving: ReadonlySet<LocalBinding>,
+): boolean {
+	const reference = unwrapLocalExpression(expression);
+	if (isGlobalMemberSink(reference, sinkNames, bindings)) {
+		return true;
+	}
+	if (!ts.isIdentifier(reference)) {
+		return false;
+	}
+	return isGlobalSinkIdentifier(reference, sinkNames, bindings, resolving);
+}
+
+function isGlobalSinkIdentifier(
+	reference: TS.Identifier,
+	sinkNames: ReadonlySet<string>,
+	bindings: LocalBindings,
+	resolving: ReadonlySet<LocalBinding>,
+): boolean {
+	const localBindings = lookupLocalBindings(reference, bindings);
+	if (localBindings === undefined || localBindings.length === 0) {
+		return sinkNames.has(reference.text);
+	}
+	return localBindings.every((binding) => {
+		if (resolving.has(binding) || binding.initializer === undefined) {
+			return false;
+		}
+		// A mutable alias is safe to resolve only when no assignment targeting
+		// this lexical binding exists in its scope (including nested closures).
+		// Reassigned let/var aliases remain unresolved to avoid false positives.
+		if (binding.mutable && binding.reassigned) {
+			return false;
+		}
+		const nextResolving = new Set(resolving);
+		nextResolving.add(binding);
+		if (binding.destructuredProperty !== undefined) {
+			return (
+				sinkNames.has(binding.destructuredProperty) &&
+				isUnshadowedGlobalObject(binding.initializer, bindings)
+			);
+		}
+		return isGlobalSinkReference(binding.initializer, sinkNames, bindings, nextResolving);
+	});
+}
+
+function isGlobalSinkCallee(
+	expression: TS.Expression,
+	sinkNames: ReadonlySet<string>,
+	bindings: LocalBindings,
+): boolean {
+	const callee = unwrapLocalExpression(expression);
+	if (isGlobalMemberSink(callee, sinkNames, bindings)) {
+		return true;
+	}
+	if (!ts.isIdentifier(callee)) {
+		return false;
+	}
+	return isGlobalSinkIdentifier(callee, sinkNames, bindings, new Set());
+}
+
+function resolveConstStringIdentifier(
+	reference: TS.Identifier,
+	bindings: LocalBindings,
+	resolving: ReadonlySet<LocalBinding> = new Set(),
+): string | undefined {
+	const localBindings = lookupLocalBindings(reference, bindings);
+	if (localBindings === undefined || localBindings.length === 0) {
+		return undefined;
+	}
+	let resolved: string | undefined;
+	for (const binding of localBindings) {
+		if (
+			resolving.has(binding) ||
+			binding.mutable ||
+			binding.initializer === undefined ||
+			binding.destructuredProperty !== undefined
+		) {
+			return undefined;
+		}
+		const nextResolving = new Set(resolving);
+		nextResolving.add(binding);
+		const initializer = unwrapLocalExpression(binding.initializer);
+		let value: string | undefined;
+		if (ts.isStringLiteral(initializer) || ts.isNoSubstitutionTemplateLiteral(initializer)) {
+			value = initializer.text;
+		} else if (ts.isIdentifier(initializer)) {
+			value = resolveConstStringIdentifier(initializer, bindings, nextResolving);
+		}
+		if (value === undefined || (resolved !== undefined && resolved !== value)) {
+			return undefined;
+		}
+		resolved = value;
+	}
+	return resolved;
+}
+
+function findGlobalSinkCalls(
+	providerRoot: string,
+	sinkNames: ReadonlySet<string>,
+	includeConstructors = false,
+): SourceFinding[] {
+	const findings: SourceFinding[] = [];
+	const seen = new Set<string>();
+	for (const filePath of listNonTestTypeScriptFiles(providerRoot)) {
+		const source = readFileSync(filePath, "utf8");
+		const relPath = toRelativeProviderPath(providerRoot, filePath);
+		const sourceFile = ts.createSourceFile(
+			relPath,
+			source,
+			ts.ScriptTarget.Latest,
+			true,
+			ts.ScriptKind.TS,
+		);
+		const bindings = collectLocalBindings(sourceFile);
+		const visit = (node: TS.Node): void => {
+			if (findings.length >= MAX_SOURCE_FINDING_EVIDENCE) {
+				return;
+			}
+			if (
+				(ts.isCallExpression(node) || (includeConstructors && ts.isNewExpression(node))) &&
+				isGlobalSinkCallee(node.expression, sinkNames, bindings)
+			) {
+				const line = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+				const key = `${relPath}:${line}`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					findings.push({ file: relPath, line });
+				}
+			}
+			ts.forEachChild(node, visit);
+		};
+		visit(sourceFile);
+		if (findings.length >= MAX_SOURCE_FINDING_EVIDENCE) {
+			break;
+		}
+	}
+	return findings;
+}
+
+function scoreNoDynamicCode(providerRoot: string): SubmitCheck {
+	const findings = findGlobalSinkCalls(providerRoot, DYNAMIC_CODE_SINKS, true);
+	if (findings.length > 0) {
+		return blocker(
+			"no-dynamic-code",
+			SDK_NATIVE_CATEGORY,
+			"Dynamic code evaluation is not permitted in provider source.",
+			"Remove eval() and Function constructor calls. Provider HTTP access must go through ctx.http.",
+			0,
+			formatSourceFindings(findings),
+		);
+	}
+
+	return pass(
+		"no-dynamic-code",
+		SDK_NATIVE_CATEGORY,
+		"Provider source avoids dynamic code evaluation.",
+		0,
+	);
+}
+
 const REDUNDANT_RUNTIME_GUARD_PATTERNS: readonly RegExp[] = [
 	/\bctx\.(?:stealth|http|cache|state|browser|trace|auth|stt|choice)\?\./,
 ];
@@ -518,7 +1003,11 @@ function countAsAssertions(providerRoot: string): {
 
 	for (const filePath of listNonTestTypeScriptFiles(providerRoot)) {
 		const content = readFileSync(filePath, "utf8");
-		const lines = content.split(/\r?\n/);
+		const lines = maskCommentsAndStrings(
+			content,
+			toRelativeProviderPath(providerRoot, filePath),
+			{ blankPropertyKeys: true },
+		).split(/\r?\n/);
 		for (let index = 0; index < lines.length; index += 1) {
 			const line = lines[index];
 			if (
@@ -709,18 +1198,44 @@ function offsetToLine(source: string, offset: number): number {
 // between them, so `.passthrough ()` / `.passthrough\n()` are still detected.
 const PASSTHROUGH_CALL = /\.passthrough\s*\(\s*\)/;
 
+type ExpressionSlice = {
+	raw: string;
+	masked: string;
+};
+
+function trimExpressionSlice(expr: ExpressionSlice): ExpressionSlice {
+	const start = expr.raw.length - expr.raw.trimStart().length;
+	const end = expr.raw.trimEnd().length;
+	return {
+		raw: expr.raw.slice(start, end),
+		masked: expr.masked.slice(start, end),
+	};
+}
+
+function balancedExpressionSlice(
+	source: string,
+	valueStart: number,
+	fileName?: string,
+): ExpressionSlice {
+	const raw = balancedValueExpression(source, valueStart, fileName);
+	return trimExpressionSlice({
+		raw,
+		masked: maskCommentsAndStrings(source, fileName).slice(valueStart, valueStart + raw.length),
+	});
+}
+
 // Strips redundant wrapping parentheses from an expression so that a value like
 // `(makeOperations())` or `((x))` classifies the same as `makeOperations()`.
 // Only unwraps when the leading `(` matches the trailing `)` at depth 0 (i.e.
 // the whole expression is parenthesized), preserving call expressions such as
 // `makeOperations()` whose first `(` is not a wrapper.
-function unwrapParens(expr: string): string {
-	let value = expr.trim();
-	while (value.startsWith("(")) {
+function unwrapParens(expr: ExpressionSlice): ExpressionSlice {
+	let value = trimExpressionSlice(expr);
+	while (value.raw.startsWith("(")) {
 		let depth = 0;
 		let matchIndex = -1;
-		for (let i = 0; i < value.length; i += 1) {
-			const ch = value[i];
+		for (let i = 0; i < value.raw.length; i += 1) {
+			const ch = value.masked[i];
 			if (ch === "(") {
 				depth += 1;
 			} else if (ch === ")") {
@@ -733,8 +1248,11 @@ function unwrapParens(expr: string): string {
 		}
 		// Only a true wrapper spans the entire expression (closing paren is the
 		// last char). Otherwise the leading `(` belongs to a sub-expression.
-		if (matchIndex === value.length - 1) {
-			value = value.slice(1, -1).trim();
+		if (matchIndex === value.raw.length - 1) {
+			value = trimExpressionSlice({
+				raw: value.raw.slice(1, -1),
+				masked: value.masked.slice(1, -1),
+			});
 		} else {
 			break;
 		}
@@ -746,8 +1264,8 @@ function unwrapParens(expr: string): string {
 // across (){}[] and stopping at the first top-level `,`/`;` or unmatched
 // closing bracket. This lets a property value be read across newlines, so a
 // multi-line `input: z.object({...})\n.passthrough()` is captured whole.
-function balancedValueExpression(source: string, valueStart: number): string {
-	const masked = maskCommentsAndStrings(source);
+function balancedValueExpression(source: string, valueStart: number, fileName?: string): string {
+	const masked = maskCommentsAndStrings(source, fileName);
 	let depth = 0;
 	let index = valueStart;
 	for (; index < source.length; index += 1) {
@@ -771,14 +1289,14 @@ function balancedValueExpression(source: string, valueStart: number): string {
 // nested deeper than the outer object (inside handler bodies, nested objects,
 // or arrays) are ignored, so only a factory composition of the object itself
 // is detected. Input is expected to start at the outer `{`.
-function hasTopLevelFactorySpread(expr: string): boolean {
-	const open = expr.indexOf("{");
+function hasTopLevelFactorySpread(expr: ExpressionSlice): boolean {
+	const open = expr.masked.indexOf("{");
 	if (open === -1) {
 		return false;
 	}
 	let depth = 0;
-	for (let i = open; i < expr.length; i += 1) {
-		const ch = expr[i];
+	for (let i = open; i < expr.raw.length; i += 1) {
+		const ch = expr.masked[i];
 		if (ch === "{" || ch === "(" || ch === "[") {
 			depth += 1;
 		} else if (ch === "}" || ch === ")" || ch === "]") {
@@ -786,11 +1304,11 @@ function hasTopLevelFactorySpread(expr: string): boolean {
 			if (depth === 0) {
 				break;
 			}
-		} else if (ch === "." && depth === 1 && expr.startsWith("...", i)) {
+		} else if (ch === "." && depth === 1 && expr.masked.startsWith("...", i)) {
 			// A spread at the object's own level. Check whether the spread
 			// argument is a call expression (factory) rather than a plain
 			// identifier/member spread of an already-built object.
-			const rest = expr.slice(i + 3);
+			const rest = expr.raw.slice(i + 3);
 			if (/^\s*[A-Za-z_$][\w$.]*\s*\(/.test(rest)) {
 				return true;
 			}
@@ -805,15 +1323,15 @@ function hasTopLevelFactorySpread(expr: string): boolean {
 // hasTopLevelFactorySpread, so it is excluded here. These identifiers must be
 // resolved to their declarations: `const hidden = makeOperations()` spread as
 // `{ ...hidden }` is still a factory-composed map and must block.
-function topLevelSpreadIdentifiers(expr: string): string[] {
-	const open = expr.indexOf("{");
+function topLevelSpreadIdentifiers(expr: ExpressionSlice): string[] {
+	const open = expr.masked.indexOf("{");
 	if (open === -1) {
 		return [];
 	}
 	const names: string[] = [];
 	let depth = 0;
-	for (let i = open; i < expr.length; i += 1) {
-		const ch = expr[i];
+	for (let i = open; i < expr.raw.length; i += 1) {
+		const ch = expr.masked[i];
 		if (ch === "{" || ch === "(" || ch === "[") {
 			depth += 1;
 		} else if (ch === "}" || ch === ")" || ch === "]") {
@@ -821,8 +1339,8 @@ function topLevelSpreadIdentifiers(expr: string): string[] {
 			if (depth === 0) {
 				break;
 			}
-		} else if (ch === "." && depth === 1 && expr.startsWith("...", i)) {
-			const rest = expr.slice(i + 3);
+		} else if (ch === "." && depth === 1 && expr.masked.startsWith("...", i)) {
+			const rest = expr.raw.slice(i + 3);
 			// Bare identifier spread (no call parens) -> needs declaration
 			// resolution. `...obj.prop` member spreads are treated as already
 			// built and ignored (the leading identifier is captured).
@@ -855,8 +1373,8 @@ function topLevelSpreadIdentifiers(expr: string): string[] {
 // `makeOperations()` — stays classified as factory composition.
 const TRANSPARENT_RESHAPE_HEAD = /^Object\s*\.\s*fromEntries\s*\(/;
 const OBJECT_ENTRIES_HEAD = /^Object\s*\.\s*entries\s*\(/;
-function isTransparentObjectReshape(expr: string): boolean {
-	const head = TRANSPARENT_RESHAPE_HEAD.exec(expr);
+function isTransparentObjectReshape(expr: ExpressionSlice): boolean {
+	const head = TRANSPARENT_RESHAPE_HEAD.exec(expr.masked);
 	if (!head) {
 		return false;
 	}
@@ -864,7 +1382,7 @@ function isTransparentObjectReshape(expr: string): boolean {
 	// transparent only when that argument's root callee is `Object.entries(`
 	// (optionally chained: `Object.entries(obj).filter(...)`), so the source
 	// object is enumerable from source rather than produced by an opaque call.
-	const firstArg = expr.slice(head[0].length).trimStart();
+	const firstArg = expr.masked.slice(head[0].length).trimStart();
 	return OBJECT_ENTRIES_HEAD.test(firstArg);
 }
 
@@ -998,7 +1516,7 @@ function scoreUnsafeInputPassthrough(providerRoot: string): SubmitCheck {
 				continue;
 			}
 			const valueStart = match.index + match[0].length;
-			const value = balancedValueExpression(source, valueStart);
+			const value = balancedValueExpression(source, valueStart, relPath);
 			if (PASSTHROUGH_CALL.test(value)) {
 				const site: ConstSite = {
 					file: relPath,
@@ -1027,8 +1545,8 @@ function scoreUnsafeInputPassthrough(providerRoot: string): SubmitCheck {
 	// that is itself a passthrough expression, or that references a passthrough
 	// const by name (resolved against the provider-wide map), is a violation.
 	for (const filePath of files) {
-		const source = fileSources.get(filePath) ?? readFileSync(filePath, "utf8");
 		const relPath = toRelativeProviderPath(providerRoot, filePath);
+		const source = fileSources.get(filePath) ?? readFileSync(filePath, "utf8");
 
 		const inputProp = /\binput\s*:\s*/g;
 		for (let match = inputProp.exec(source); match !== null; match = inputProp.exec(source)) {
@@ -1039,7 +1557,7 @@ function scoreUnsafeInputPassthrough(providerRoot: string): SubmitCheck {
 				continue;
 			}
 			const valueStart = match.index + match[0].length;
-			const value = balancedValueExpression(source, valueStart);
+			const value = balancedValueExpression(source, valueStart, relPath);
 			if (PASSTHROUGH_CALL.test(value)) {
 				push({ file: relPath, line: offsetToLine(source, valueStart) });
 				continue;
@@ -1150,13 +1668,19 @@ function spreadIdentifierResolvesToFactory(
 		if (!existsSync(filePath)) {
 			continue;
 		}
+		const relPath = toRelativeProviderPath(providerRoot, filePath);
 		const fileSource = filePath === indexPath ? indexSource : readFileSync(filePath, "utf8");
+		const maskedFileSource = maskCommentsAndStrings(fileSource, relPath, {
+			blankPropertyKeys: true,
+		});
 		const re = new RegExp(declRe.source, "g");
-		for (let m = re.exec(fileSource); m !== null; m = re.exec(fileSource)) {
+		for (let m = re.exec(maskedFileSource); m !== null; m = re.exec(maskedFileSource)) {
 			sawDeclaration = true;
-			const expr = unwrapParens(balancedValueExpression(fileSource, m.index + m[0].length).trim());
+			const expr = unwrapParens(
+				balancedExpressionSlice(fileSource, m.index + m[0].length, relPath),
+			);
 			const isFactory =
-				(/^[A-Za-z_$][\w$.]*\s*\(/.test(expr) || hasTopLevelFactorySpread(expr)) &&
+				(/^[A-Za-z_$][\w$.]*\s*\(/.test(expr.masked) || hasTopLevelFactorySpread(expr)) &&
 				!isTransparentObjectReshape(expr);
 			if (isFactory) {
 				return true;
@@ -1165,12 +1689,232 @@ function spreadIdentifierResolvesToFactory(
 	}
 	// No local declaration anywhere but imported into index.ts => constructed
 	// out of view; treat as factory (conservative, false-negative-safe).
-	if (!sawDeclaration && fileImportsBinding(indexSource, name)) {
+	if (
+		!sawDeclaration &&
+		fileImportsBinding(
+			maskCommentsAndStrings(indexSource, "index.ts", { blankPropertyKeys: true }),
+			name,
+		)
+	) {
 		return true;
 	}
 	return false;
 }
 
+function isDefineProviderCall(node: TS.CallExpression): boolean {
+	return ts.isIdentifier(node.expression) && node.expression.text === "defineProvider";
+}
+
+function resolveDefineProviderImplementationCall(
+	candidate: TS.CallExpression,
+): TS.CallExpression | undefined {
+	let root = candidate;
+	while (ts.isCallExpression(root.expression)) {
+		root = root.expression;
+	}
+	return isDefineProviderCall(root) ? candidate : undefined;
+}
+
+function findProviderImplementationCall(sourceFile: TS.SourceFile): TS.CallExpression | undefined {
+	const defaultExports = sourceFile.statements.filter(
+		(statement): statement is TS.ExportAssignment =>
+			ts.isExportAssignment(statement) && !statement.isExportEquals,
+	);
+
+	// Phase-separated providers export a builder invocation directly. Preserve
+	// the previous locator's preference for that call over every defineProvider
+	// declaration that may also appear in the file.
+	for (const assignment of defaultExports) {
+		const expression = unwrapImplementationExpression(assignment.expression);
+		if (!ts.isCallExpression(expression)) {
+			continue;
+		}
+		if (resolveDefineProviderImplementationCall(expression) !== undefined) {
+			continue;
+		}
+		if (ts.isIdentifier(expression.expression)) {
+			return expression;
+		}
+	}
+
+	// For `defineProvider(metadata)(implementation)`, select the outer call whose
+	// argument is the implementation. A plain `defineProvider(implementation)`
+	// selects the single call itself.
+	for (const assignment of defaultExports) {
+		const defaultExpression = unwrapImplementationExpression(assignment.expression);
+		if (!ts.isCallExpression(defaultExpression)) {
+			continue;
+		}
+		const implementationCall = resolveDefineProviderImplementationCall(defaultExpression);
+		if (implementationCall !== undefined) {
+			return implementationCall;
+		}
+	}
+
+	// Resolve `export default provider` to a top-level variable initialized by
+	// defineProvider, including its curried implementation call when present.
+	for (const assignment of defaultExports) {
+		if (!ts.isIdentifier(assignment.expression)) {
+			continue;
+		}
+		const exportedName = assignment.expression.text;
+		for (const statement of sourceFile.statements) {
+			if (!ts.isVariableStatement(statement)) {
+				continue;
+			}
+			for (const declaration of statement.declarationList.declarations) {
+				if (
+					!ts.isIdentifier(declaration.name) ||
+					declaration.name.text !== exportedName ||
+					declaration.initializer === undefined
+				) {
+					continue;
+				}
+				if (!ts.isCallExpression(declaration.initializer)) {
+					continue;
+				}
+				const implementationCall = resolveDefineProviderImplementationCall(declaration.initializer);
+				if (implementationCall !== undefined) {
+					return implementationCall;
+				}
+			}
+		}
+	}
+
+	// Structural fixtures without a recognizable default export retain the
+	// previous fallback to the first defineProvider call in source order.
+	let firstCall: TS.CallExpression | undefined;
+	const visit = (node: TS.Node): void => {
+		if (firstCall !== undefined) {
+			return;
+		}
+		if (ts.isCallExpression(node)) {
+			const implementationCall = resolveDefineProviderImplementationCall(node);
+			if (implementationCall !== undefined) {
+				firstCall = implementationCall;
+				return;
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return firstCall;
+}
+
+function unwrapImplementationExpression(expression: TS.Expression): TS.Expression {
+	let current = expression;
+	while (
+		ts.isSatisfiesExpression(current) ||
+		ts.isAsExpression(current) ||
+		ts.isParenthesizedExpression(current) ||
+		ts.isNonNullExpression(current)
+	) {
+		current = current.expression;
+	}
+	return current;
+}
+
+function isOperationsProperty(
+	property: TS.ObjectLiteralElementLike,
+): property is TS.PropertyAssignment | TS.ShorthandPropertyAssignment {
+	if (ts.isShorthandPropertyAssignment(property)) {
+		return property.name.text === "operations";
+	}
+	if (!ts.isPropertyAssignment(property)) {
+		return false;
+	}
+	return (
+		(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
+		property.name.text === "operations"
+	);
+}
+
+function isOperationsAccessorOrMethod(
+	property: TS.ObjectLiteralElementLike,
+): property is TS.GetAccessorDeclaration | TS.SetAccessorDeclaration | TS.MethodDeclaration {
+	if (
+		!ts.isGetAccessorDeclaration(property) &&
+		!ts.isSetAccessorDeclaration(property) &&
+		!ts.isMethodDeclaration(property)
+	) {
+		return false;
+	}
+	return (
+		(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) &&
+		property.name.text === "operations"
+	);
+}
+
+function isSourceEnumerableStaticObjectLiteral(expression: TS.Expression): boolean {
+	const unwrapped = unwrapImplementationExpression(expression);
+	if (!ts.isObjectLiteralExpression(unwrapped)) {
+		return false;
+	}
+	return unwrapped.properties.every((property) => {
+		if (ts.isSpreadAssignment(property)) {
+			return isSourceEnumerableStaticObjectLiteral(property.expression);
+		}
+		if (property.name === undefined || ts.isComputedPropertyName(property.name)) {
+			return property.name === undefined;
+		}
+		return property.name.text !== "operations" || isOperationsProperty(property);
+	});
+}
+
+function findComputedImplementationProperty(
+	objectLiteral: TS.ObjectLiteralExpression,
+): TS.ObjectLiteralElementLike | undefined {
+	for (const property of objectLiteral.properties) {
+		if (property.name !== undefined && ts.isComputedPropertyName(property.name)) {
+			return property;
+		}
+		if (ts.isSpreadAssignment(property)) {
+			const spreadExpression = unwrapImplementationExpression(property.expression);
+			if (ts.isObjectLiteralExpression(spreadExpression)) {
+				const nested = findComputedImplementationProperty(spreadExpression);
+				if (nested !== undefined) {
+					return nested;
+				}
+			}
+		}
+	}
+	return undefined;
+}
+
+function findEffectiveOperationsProperty(
+	objectLiteral: TS.ObjectLiteralExpression,
+):
+	| TS.PropertyAssignment
+	| TS.ShorthandPropertyAssignment
+	| TS.GetAccessorDeclaration
+	| TS.SetAccessorDeclaration
+	| TS.MethodDeclaration
+	| undefined {
+	let effective:
+		| TS.PropertyAssignment
+		| TS.ShorthandPropertyAssignment
+		| TS.GetAccessorDeclaration
+		| TS.SetAccessorDeclaration
+		| TS.MethodDeclaration
+		| undefined;
+	for (const property of objectLiteral.properties) {
+		if (isOperationsProperty(property) || isOperationsAccessorOrMethod(property)) {
+			effective = property;
+			continue;
+		}
+		if (ts.isSpreadAssignment(property)) {
+			const spreadExpression = unwrapImplementationExpression(property.expression);
+			if (ts.isObjectLiteralExpression(spreadExpression)) {
+				const nested = findEffectiveOperationsProperty(spreadExpression);
+				if (nested !== undefined) {
+					effective = nested;
+				}
+			}
+		}
+	}
+	return effective;
+}
+
 function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 	const indexPath = resolve(providerRoot, "index.ts");
 	const ruleId = "flat-operation-composition";
@@ -1184,10 +1928,23 @@ function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 	}
 
 	const source = readFileSync(indexPath, "utf8");
-	// Use the same whitespace-tolerant detection as the resolver below, so a
-	// `defineProvider (` / `defineProvider\n(` formatting cannot pass the early
-	// exit before the real classification runs.
-	if (!/\bdefineProvider\s*\(/.test(source)) {
+	const indexRelPath = toRelativeProviderPath(providerRoot, indexPath);
+	// The report preflight already rejects unparseable index.ts sources before
+	// this rule runs, so this local AST parse only replaces property location.
+	const sourceFile = ts.createSourceFile(
+		indexRelPath,
+		source,
+		ts.ScriptTarget.Latest,
+		true,
+		ts.ScriptKind.TS,
+	);
+	const implementationCall = findProviderImplementationCall(sourceFile);
+	const rawImplementationArg = implementationCall?.arguments[0];
+	const implementationArg =
+		rawImplementationArg === undefined
+			? undefined
+			: unwrapImplementationExpression(rawImplementationArg);
+	if (implementationArg === undefined || !ts.isObjectLiteralExpression(implementationArg)) {
 		return pass(
 			ruleId,
 			SDK_NATIVE_CATEGORY,
@@ -1196,82 +1953,78 @@ function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 		);
 	}
 
-	// Scope the scan to the exported provider builder's implementation argument,
-	// or to the legacy-looking declaration call used by structural test fixtures.
-	// A provider can contain helper/non-exported defineProvider calls before the
-	// real default export (e.g. test scaffolds), so resolve the default export
-	// rather than blindly taking the first regex match. Resolution order:
-	//   1. `export default <builder>(` — phase-separated provider
-	//   2. `export default defineProvider(` — structural fixture
-	//   3. `export default <ident>` then `const <ident> = defineProvider(`
-	//   4. fallback: first `defineProvider(` in the file
-	let defineParenIndex = -1;
-	const builderDefault = /\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*\(/.exec(source);
-	if (builderDefault?.[1] !== undefined && builderDefault[1] !== "defineProvider") {
-		defineParenIndex = builderDefault.index + builderDefault[0].length - 1;
-	}
-	const inlineDefault = /\bexport\s+default\s+defineProvider\s*\(/.exec(source);
-	if (defineParenIndex === -1 && inlineDefault) {
-		const declarationParen = inlineDefault.index + inlineDefault[0].length - 1;
-		const declarationStart = declarationParen + 1;
-		const declaration = balancedValueExpression(source, declarationStart);
-		let cursor = declarationStart + declaration.length;
-		while (/\s/.test(source[cursor] ?? "")) cursor++;
-		if (source[cursor] === ")") cursor++;
-		while (/\s/.test(source[cursor] ?? "")) cursor++;
-		defineParenIndex = source[cursor] === "(" ? cursor : declarationParen;
-	} else if (defineParenIndex === -1) {
-		const namedDefault = /\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*;?/.exec(source);
-		const exportedName = namedDefault?.[1];
-		if (exportedName !== undefined) {
-			const namedDecl = new RegExp(
-				`(?:^|\\n)[ \t]*(?:export\\s+)?(?:const|let|var)\\s+${exportedName}\\s*(?::[^=\\n]+)?\\s*=\\s*defineProvider\\s*\\(`,
-			).exec(source);
-			if (namedDecl) {
-				defineParenIndex = namedDecl.index + namedDecl[0].length - 1;
-			}
-		}
-		if (defineParenIndex === -1) {
-			const firstCall = /\bdefineProvider\s*\(/.exec(source);
-			if (firstCall) {
-				defineParenIndex = firstCall.index + firstCall[0].length - 1;
-			}
-		}
+	// Resolve the top-level operations property from the AST, then feed its raw
+	// initializer offset into the existing expression classifier and alias
+	// resolver unchanged.
+	const opsProp = findEffectiveOperationsProperty(implementationArg);
+	let opsValue: ExpressionSlice | undefined;
+	let opsLine = 1;
+	if (opsProp !== undefined && ts.isPropertyAssignment(opsProp)) {
+		const valueStart = opsProp.initializer.getStart(sourceFile);
+		opsValue = unwrapParens(balancedExpressionSlice(source, valueStart, indexRelPath));
+		opsLine = offsetToLine(source, valueStart);
 	}
-	if (defineParenIndex === -1) {
-		return pass(
+
+	// Property shorthand: `buildProvider({ operations })` — resolve the
+	// local `operations` const initializer.
+	let aliasName: string | undefined;
+	if (opsProp !== undefined && ts.isShorthandPropertyAssignment(opsProp)) {
+		aliasName = "operations";
+	} else if (opsValue !== undefined && /^[A-Za-z_$][\w$]*$/.test(opsValue.masked)) {
+		// `operations: ops` — a bare identifier alias to resolve.
+		aliasName = opsValue.raw;
+	}
+
+	// A computed property might resolve to `operations`, but its composition is
+	// not source-enumerable here. Fail closed, like an unresolved imported alias.
+	const computed = findComputedImplementationProperty(implementationArg);
+	if (computed !== undefined) {
+		const computedLine = offsetToLine(source, computed.getStart(sourceFile));
+		return blocker(
 			ruleId,
 			SDK_NATIVE_CATEGORY,
-			"No defineProvider call to evaluate for operation composition.",
+			"The defineProvider operations property uses a computed property name that cannot be statically resolved.",
+			"Declare operations with the literal property name `operations` and a static object literal value so the provider-registry AST gate can enumerate it.",
 			0,
+			[`${indexRelPath}:${computedLine} (computed property name)`],
 		);
 	}
-	const argStart = defineParenIndex + 1;
-	const argText = balancedValueExpression(source, argStart);
 
-	// Resolve the value passed as `operations:` inside the implementation call,
-	// following one alias hop. The value is classified as a static object
-	// literal (pass) or a factory/call expression (block). The regex index is
-	// offset back into the full source so line numbers stay accurate.
-	const opsProp = /\boperations\s*:\s*/.exec(argText);
-	let opsValue: string | undefined;
-	let opsLine = 1;
-	if (opsProp) {
-		const valueStart = argStart + opsProp.index + opsProp[0].length;
-		opsValue = unwrapParens(balancedValueExpression(source, valueStart).trim());
-		opsLine = offsetToLine(source, valueStart);
+	if (opsProp !== undefined && isOperationsAccessorOrMethod(opsProp)) {
+		const memberLine = offsetToLine(source, opsProp.getStart(sourceFile));
+		return blocker(
+			ruleId,
+			SDK_NATIVE_CATEGORY,
+			"The defineProvider operations member is an accessor/method whose value is not statically enumerable.",
+			"Declare operations as a property assignment with a static object literal value so the provider-registry AST gate can enumerate it.",
+			0,
+			[`${indexRelPath}:${memberLine} (operations accessor/method)`],
+		);
 	}
 
-	// Property shorthand: `buildProvider({ operations })` — resolve the
-	// local `operations` const initializer.
-	let aliasName: string | undefined;
-	if (opsValue === undefined) {
-		if (/\boperations\s*[,}]/.test(argText)) {
-			aliasName = "operations";
-		}
-	} else if (/^[A-Za-z_$][\w$]*$/.test(opsValue)) {
-		// `operations: ops` — a bare identifier alias to resolve.
-		aliasName = opsValue;
+	// A spread can override a preceding literal `operations` property. Only an
+	// inline static object literal (including recursively inline static spreads)
+	// exposes all of its property names to this source-only gate. Identifiers,
+	// calls, and other expressions are opaque and therefore fail closed.
+	const opaqueSpread = implementationArg.properties.find(
+		(property): property is TS.SpreadAssignment =>
+			ts.isSpreadAssignment(property) &&
+			!isSourceEnumerableStaticObjectLiteral(property.expression),
+	);
+	if (opaqueSpread !== undefined) {
+		const spreadLine = offsetToLine(source, opaqueSpread.getStart(sourceFile));
+		return escapeHatchResult(
+			providerRoot,
+			ruleId,
+			[{ file: indexRelPath, line: spreadLine }],
+			{
+				blockerMessage:
+					"The defineProvider implementation uses a non-enumerable spread that could override operations.",
+				remediation:
+					"Declare operations directly with a static object literal. Implementation spreads must be inline static object literals so the provider-registry AST gate can enumerate every property name.",
+				passMessage: "defineProvider declares operations as a static object literal.",
+			},
+		);
 	}
 
 	// Determine the effective initializer expression to classify. The alias may
@@ -1305,7 +2058,7 @@ function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 		// do not resolve the exact import target path; "any same-named factory
 		// blocks" is the conservative, false-negative-avoiding choice for a gate.)
 		type Candidate = {
-			expr: string;
+			expr: ExpressionSlice;
 			line: number;
 			file: string;
 			isFactory: boolean;
@@ -1315,15 +2068,22 @@ function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 			if (!existsSync(filePath)) {
 				continue;
 			}
-			const fileSource = filePath === indexPath ? source : readFileSync(filePath, "utf8");
 			const relPath = toRelativeProviderPath(providerRoot, filePath);
+			const fileSource = filePath === indexPath ? source : readFileSync(filePath, "utf8");
+			const maskedFileSource = maskCommentsAndStrings(fileSource, relPath, {
+				blankPropertyKeys: true,
+			});
 
 			const declRe = new RegExp(aliasDecl.source, "g");
-			for (let m = declRe.exec(fileSource); m !== null; m = declRe.exec(fileSource)) {
+			for (
+				let m = declRe.exec(maskedFileSource);
+				m !== null;
+				m = declRe.exec(maskedFileSource)
+			) {
 				const valueStart = m.index + m[0].length;
-				const expr = unwrapParens(balancedValueExpression(fileSource, valueStart).trim());
+				const expr = unwrapParens(balancedExpressionSlice(fileSource, valueStart, relPath));
 				const isFactory =
-					(/^[A-Za-z_$][\w$.]*\s*\(/.test(expr) || hasTopLevelFactorySpread(expr)) &&
+					(/^[A-Za-z_$][\w$.]*\s*\(/.test(expr.masked) || hasTopLevelFactorySpread(expr)) &&
 					!isTransparentObjectReshape(expr);
 				candidates.push({
 					expr,
@@ -1333,9 +2093,14 @@ function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 				});
 			}
 			const destructRe = new RegExp(destructured.source, "g");
-			for (let m = destructRe.exec(fileSource); m !== null; m = destructRe.exec(fileSource)) {
+			for (
+				let m = destructRe.exec(maskedFileSource);
+				m !== null;
+				m = destructRe.exec(maskedFileSource)
+			) {
+				const raw = `${m[1]}(`;
 				candidates.push({
-					expr: `${m[1]}(`,
+					expr: { raw, masked: raw },
 					line: offsetToLine(fileSource, m.index),
 					file: relPath,
 					isFactory: true,
@@ -1361,11 +2126,15 @@ function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 		// the unresolved import as a factory-composed (non-static) shape rather
 		// than silently passing.
 		if (!resolved) {
-			const importMatch = new RegExp(`\\bimport\\b[^;]*\\b${aliasName}\\b[^;]*\\bfrom\\b`).exec(
-				source,
-			);
+			const maskedIndexSource = maskCommentsAndStrings(source, indexRelPath, {
+				blankPropertyKeys: true,
+			});
+			const importMatch = new RegExp(
+				`\\bimport\\b[^;]*\\b${aliasName}\\b[^;]*\\bfrom\\b`,
+			).exec(maskedIndexSource);
 			if (importMatch) {
-				effective = `${aliasName}(`;
+				const raw = `${aliasName}(`;
+				effective = { raw, masked: raw };
 				effectiveLine = offsetToLine(source, importMatch.index);
 				effectiveFile = "index.ts";
 			}
@@ -1389,14 +2158,16 @@ function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 			spreadIdentifierResolvesToFactory(providerRoot, indexPath, source, name),
 		);
 	const isStaticLiteral =
-		effective?.startsWith("{") === true && !hasFactorySpread && !hasFactorySpreadIdentifier;
+		effective?.masked.startsWith("{") === true && !hasFactorySpread && !hasFactorySpreadIdentifier;
 	// A call expression `ident(...)` (factory) or a factory-spread literal is
 	// the rejected, non-static shape — UNLESS it is the stdlib
 	// `Object.fromEntries(Object.entries(<source-visible obj>)...)` reshape,
 	// whose op set is still enumerable from source (verified golden pattern).
 	const isFactoryCall =
 		effective !== undefined &&
-		(/^[A-Za-z_$][\w$.]*\s*\(/.test(effective) || hasFactorySpread || hasFactorySpreadIdentifier) &&
+		(/^[A-Za-z_$][\w$.]*\s*\(/.test(effective.masked) ||
+			hasFactorySpread ||
+			hasFactorySpreadIdentifier) &&
 		!isTransparentObjectReshape(effective);
 
 	if (isFactoryCall && !isStaticLiteral) {
@@ -1422,7 +2193,7 @@ function scoreFlatOperationComposition(providerRoot: string): SubmitCheck {
 }
 
 function scoreCredentialUsage(providerRoot: string, provider: ProviderDefinition): SubmitCheck {
-	const credentialReferences = findSourceLineMatches(providerRoot, /ctx\.credential/);
+	const credentialReferences = findCredentialReferences(providerRoot);
 	const authMode = provider.auth?.mode ?? "none";
 	const credentialKeys = provider.credential?.keys ?? [];
 	const storesProviderCredential = authMode !== "none" || credentialKeys.length > 0;
@@ -1440,16 +2211,117 @@ function scoreCredentialUsage(providerRoot: string, provider: ProviderDefinition
 				"Persist provider session state through the SDK credential context instead of process-local state. See providers/catchtable for the reference pattern.",
 		};
 	}
-
-	return pass(
-		"credential-usage",
-		SDK_NATIVE_CATEGORY,
-		authMode === "none" && credentialKeys.length === 0
-			? "Provider does not declare reusable credentials."
-			: "Credential-backed provider references ctx.credential.",
-		0,
-		credentialReferences.length > 0 ? formatSourceFindings(credentialReferences) : undefined,
-	);
+
+	return pass(
+		"credential-usage",
+		SDK_NATIVE_CATEGORY,
+		authMode === "none" && credentialKeys.length === 0
+			? "Provider does not declare reusable credentials."
+			: "Credential-backed provider references ctx.credential.",
+		0,
+		credentialReferences.length > 0 ? formatSourceFindings(credentialReferences) : undefined,
+	);
+}
+
+function isDirectCredentialReference(expression: TS.Expression): boolean {
+	const reference = unwrapLocalExpression(expression);
+	let receiver: TS.Expression | undefined;
+	let memberName: string | undefined;
+	if (ts.isPropertyAccessExpression(reference)) {
+		receiver = reference.expression;
+		memberName = reference.name.text;
+	} else if (ts.isElementAccessExpression(reference)) {
+		receiver = reference.expression;
+		const argument = reference.argumentExpression;
+		if (
+			argument !== undefined &&
+			(ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument))
+		) {
+			memberName = argument.text;
+		}
+	}
+	const unwrappedReceiver = receiver === undefined ? undefined : unwrapLocalExpression(receiver);
+	return (
+		memberName === "credential" &&
+		unwrappedReceiver !== undefined &&
+		ts.isIdentifier(unwrappedReceiver) &&
+		unwrappedReceiver.text === "ctx"
+	);
+}
+
+function isCredentialReference(
+	expression: TS.Expression,
+	bindings: LocalBindings,
+	resolving: ReadonlySet<LocalBinding> = new Set(),
+): boolean {
+	const reference = unwrapLocalExpression(expression);
+	if (isDirectCredentialReference(reference)) {
+		return true;
+	}
+	if (!ts.isIdentifier(reference)) {
+		return false;
+	}
+	const localBindings = lookupLocalBindings(reference, bindings);
+	if (localBindings === undefined || localBindings.length === 0) {
+		return false;
+	}
+	return localBindings.every((binding) => {
+		if (resolving.has(binding) || binding.mutable || binding.initializer === undefined) {
+			return false;
+		}
+		const nextResolving = new Set(resolving);
+		nextResolving.add(binding);
+		if (binding.destructuredProperty !== undefined) {
+			const source = unwrapLocalExpression(binding.initializer);
+			return (
+				binding.destructuredProperty === "credential" &&
+				ts.isIdentifier(source) &&
+				source.text === "ctx"
+			);
+		}
+		return isCredentialReference(binding.initializer, bindings, nextResolving);
+	});
+}
+
+function findCredentialReferences(providerRoot: string): SourceFinding[] {
+	const findings: SourceFinding[] = [];
+	const seen = new Set<string>();
+	for (const filePath of listNonTestTypeScriptFiles(providerRoot)) {
+		const source = readFileSync(filePath, "utf8");
+		const relPath = toRelativeProviderPath(providerRoot, filePath);
+		const sourceFile = ts.createSourceFile(
+			relPath,
+			source,
+			ts.ScriptTarget.Latest,
+			true,
+			ts.ScriptKind.TS,
+		);
+		const bindings = collectLocalBindings(sourceFile);
+		const visit = (node: TS.Node): void => {
+			if (findings.length >= MAX_SOURCE_FINDING_EVIDENCE) {
+				return;
+			}
+			if (
+				ts.isExpression(node) &&
+				(isDirectCredentialReference(node) ||
+					((ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
+						isCredentialReference(node.expression, bindings)))
+			) {
+				const line = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+				const key = `${relPath}:${line}`;
+				if (!seen.has(key)) {
+					seen.add(key);
+					findings.push({ file: relPath, line });
+				}
+			}
+			ts.forEachChild(node, visit);
+		};
+		visit(sourceFile);
+		if (findings.length >= MAX_SOURCE_FINDING_EVIDENCE) {
+			break;
+		}
+	}
+	return findings;
 }
 
 // ---------------------------------------------------------------------------
@@ -1608,23 +2480,34 @@ function scoreSdkOwnedSecretPresence(
 function findSourceLineMatches(
 	providerRoot: string,
 	pattern: RegExp | ((line: string) => boolean),
+	useMaskedSource = false,
 ): SourceFinding[] {
-	return findSourceFindings(providerRoot, (line) => matchesLinePattern(line, pattern));
+	return findSourceFindings(
+		providerRoot,
+		(line) => matchesLinePattern(line, pattern),
+		useMaskedSource,
+	);
 }
 
 function findSourceFindings(
 	providerRoot: string,
 	matchesLine: (line: string, remainingLines: readonly string[]) => boolean,
+	useMaskedSource = false,
 ): SourceFinding[] {
 	const findings: SourceFinding[] = [];
 	for (const filePath of listNonTestTypeScriptFiles(providerRoot)) {
 		const content = readFileSync(filePath, "utf8");
-		const lines = content.split(/\r?\n/);
+		const relPath = toRelativeProviderPath(providerRoot, filePath);
+		const lines = (
+			useMaskedSource
+				? maskCommentsAndStrings(content, relPath, { blankPropertyKeys: true })
+				: content
+		).split(/\r?\n/);
 		for (let index = 0; index < lines.length; index += 1) {
 			const line = lines[index];
 			if (line !== undefined && matchesLine(line, lines.slice(index + 1))) {
 				findings.push({
-					file: toRelativeProviderPath(providerRoot, filePath),
+					file: relPath,
 					line: index + 1,
 				});
 				if (findings.length >= MAX_SOURCE_FINDING_EVIDENCE) {
@@ -1740,7 +2623,10 @@ function toRelativeProviderPath(providerRoot: string, filePath: string): string
 }
 
 function formatSourceFindings(findings: readonly SourceFinding[]): string[] {
-	return findings.map((finding) => `${finding.file}:${finding.line}`);
+	return findings.map(
+		(finding) =>
+			`${finding.file}:${finding.line}${finding.detail === undefined ? "" : `: ${finding.detail}`}`,
+	);
 }
 
 function scorePromptAssetFreshness(providerRoot: string): SubmitCheck {
@@ -1836,7 +2722,7 @@ async function safeRunChecks(providerRoot: string): Promise<CheckResult[]> {
 			{
 				message: "Base provider checks can run",
 				passed: false,
-				details: [error instanceof Error ? error.message : String(error)],
+				details: [formatThrownValue(error)],
 			},
 		];
 	}
@@ -2392,19 +3278,37 @@ function findVendorKeyLeakFindings(providerRoot: string): SourceFinding[] {
 	for (const filePath of listNonTestTypeScriptFiles(providerRoot)) {
 		const source = readFileSync(filePath, "utf8");
 		const relPath = toRelativeProviderPath(providerRoot, filePath);
+		maskCommentsAndStrings(source, relPath);
+		const sourceFile = ts.createSourceFile(
+			relPath,
+			source,
+			ts.ScriptTarget.Latest,
+			true,
+			ts.ScriptKind.TS,
+		);
+		const bindings = collectLocalBindings(sourceFile);
 		const upstreamRanges = findUpstreamMarkedConstRanges(source);
 		for (const zObject of findZObjectLiterals(source)) {
 			if (rangeContainsOffset(upstreamRanges, zObject.callStart)) {
 				continue;
 			}
-			if (!zObjectAppearsPublicOutput(source, zObject)) {
+			if (!zObjectAppearsPublicOutput(sourceFile, zObject, relPath)) {
 				continue;
 			}
-			for (const keyFinding of vendorKeyFindingsForObject(source, zObject)) {
+			for (const keyFinding of vendorKeyFindingsForObject(
+				source,
+				sourceFile,
+				zObject,
+				bindings,
+			)) {
 				const key = `${relPath}:${keyFinding.line}:${keyFinding.key}`;
 				if (!seen.has(key)) {
 					seen.add(key);
-					findings.push({ file: relPath, line: keyFinding.line });
+					findings.push({
+						file: relPath,
+						line: keyFinding.line,
+						detail: keyFinding.key,
+					});
 					if (findings.length >= MAX_SOURCE_FINDING_EVIDENCE) {
 						return findings;
 					}
@@ -2440,20 +3344,260 @@ function findZObjectLiterals(source: string): ZObjectLiteral[] {
 	return literals;
 }
 
-function zObjectAppearsPublicOutput(source: string, zObject: ZObjectLiteral): boolean {
-	const enclosingConst = findConstValueRangeContaining(source, zObject.callStart);
-	if (enclosingConst && /output|response|result/i.test(enclosingConst.name)) {
+function zObjectAppearsPublicOutput(
+	sourceFile: TS.SourceFile,
+	zObject: ZObjectLiteral,
+	relPath: string,
+): boolean {
+	let zObjectCall: TS.CallExpression | undefined;
+	const findCall = (node: TS.Node): void => {
+		if (
+			zObjectCall === undefined &&
+			ts.isCallExpression(node) &&
+			node.getStart(sourceFile) === zObject.callStart
+		) {
+			zObjectCall = node;
+			return;
+		}
+		ts.forEachChild(node, findCall);
+	};
+	findCall(sourceFile);
+	if (zObjectCall === undefined) {
+		return true;
+	}
+
+	let expression: TS.Expression = zObjectCall;
+	while (
+		ts.isParenthesizedExpression(expression.parent) ||
+		ts.isAsExpression(expression.parent) ||
+		ts.isSatisfiesExpression(expression.parent) ||
+		ts.isNonNullExpression(expression.parent)
+	) {
+		expression = expression.parent;
+	}
+	if (
+		ts.isPropertyAssignment(expression.parent) &&
+		isPublicOutputPropertyName(expression.parent.name)
+	) {
+		return true;
+	}
+
+	const declaration = findEnclosingVariableDeclaration(expression);
+	if (
+		declaration === undefined ||
+		!ts.isIdentifier(declaration.name) ||
+		declaration.initializer === undefined ||
+		!ts.isVariableDeclarationList(declaration.parent) ||
+		(declaration.parent.flags & ts.NodeFlags.Const) === 0
+	) {
+		return true;
+	}
+
+	const reachability = localSchemaBindingReachability(
+		sourceFile,
+		declaration.name.text,
+		declaration,
+		new Set(),
+	);
+	if (reachability === "public") {
+		return true;
+	}
+	if (reachability === "unknown") {
+		return true;
+	}
+	// Sibling modules are scanned independently and therefore remain
+	// fail-closed. An exported binding in index.ts is likewise consumable by
+	// another module, so local inertness does not prove it is private.
+	if (relPath !== "index.ts") {
+		return true;
+	}
+	return isExportedVariableBinding(sourceFile, declaration);
+}
+
+type SchemaReachability = "public" | "internal" | "unknown";
+
+const PARSE_LIKE_SCHEMA_METHODS: ReadonlySet<string> = new Set([
+	"parse",
+	"safeParse",
+	"parseAsync",
+	"safeParseAsync",
+]);
+
+function isExportedVariableBinding(
+	sourceFile: TS.SourceFile,
+	declaration: TS.VariableDeclaration,
+): boolean {
+	const declarationStatement = declaration.parent.parent;
+	if (
+		ts.isVariableStatement(declarationStatement) &&
+		declarationStatement.modifiers?.some(
+			(modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+		) === true
+	) {
 		return true;
 	}
-	const before = source.slice(Math.max(0, zObject.callStart - 160), zObject.callStart);
-	return /(?:^|[\s,{])(?:output|response)\s*:\s*$/.test(before);
+	if (!ts.isIdentifier(declaration.name)) {
+		return false;
+	}
+	const name = declaration.name.text;
+	let exported = false;
+	const visit = (node: TS.Node): void => {
+		if (exported) {
+			return;
+		}
+		if (ts.isExportSpecifier(node)) {
+			const localName = node.propertyName ?? node.name;
+			if (ts.isIdentifier(localName) && localName.text === name) {
+				exported = true;
+				return;
+			}
+		}
+		if (ts.isExportAssignment(node)) {
+			const expression = unwrapLocalExpression(node.expression);
+			if (ts.isIdentifier(expression) && expression.text === name) {
+				exported = true;
+				return;
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	for (const statement of sourceFile.statements) {
+		visit(statement);
+		if (exported) {
+			break;
+		}
+	}
+	return exported;
+}
+
+function isPublicOutputPropertyName(name: TS.PropertyName): boolean {
+	const text = propertyNameText(name);
+	return text === "output" || text === "response";
+}
+
+function findEnclosingVariableDeclaration(node: TS.Node): TS.VariableDeclaration | undefined {
+	let current: TS.Node | undefined = node;
+	while (current !== undefined && !ts.isSourceFile(current)) {
+		if (ts.isVariableDeclaration(current)) {
+			return current;
+		}
+		current = current.parent;
+	}
+	return undefined;
+}
+
+function localSchemaBindingReachability(
+	sourceFile: TS.SourceFile,
+	name: string,
+	declaration: TS.VariableDeclaration,
+	resolving: ReadonlySet<string>,
+): SchemaReachability {
+	if (resolving.has(name)) {
+		return "unknown";
+	}
+	const nextResolving = new Set(resolving);
+	nextResolving.add(name);
+	let result: SchemaReachability = "internal";
+	const visit = (node: TS.Node): void => {
+		if (result === "public") {
+			return;
+		}
+		if (ts.isIdentifier(node) && node.text === name && node !== declaration.name) {
+			const parent = node.parent;
+			if (isParseLikeSchemaReceiver(node)) {
+				return;
+			}
+			if (ts.isExportSpecifier(parent)) {
+				const localName = parent.propertyName ?? parent.name;
+				if (localName === node) {
+					result = "public";
+				}
+				return;
+			}
+			if (
+				ts.isPropertyAssignment(parent) &&
+				parent.initializer === node &&
+				isPublicOutputPropertyName(parent.name)
+			) {
+				result = "public";
+				return;
+			}
+			if (ts.isShorthandPropertyAssignment(parent)) {
+				result = isPublicOutputPropertyName(parent.name) ? "public" : "unknown";
+				return;
+			}
+			if (
+				ts.isVariableDeclaration(parent) &&
+				parent.initializer === node &&
+				ts.isIdentifier(parent.name) &&
+				ts.isVariableDeclarationList(parent.parent) &&
+				(parent.parent.flags & ts.NodeFlags.Const) !== 0
+			) {
+				const aliasReachability = localSchemaBindingReachability(
+					sourceFile,
+					parent.name.text,
+					parent,
+					nextResolving,
+				);
+				if (aliasReachability === "public" || result === "internal") {
+					result = aliasReachability;
+				}
+				return;
+			}
+			if (ts.isVoidExpression(parent) || ts.isTypeOfExpression(parent)) {
+				return;
+			}
+			if (
+				(ts.isPropertyAccessExpression(parent) && parent.name === node) ||
+				(ts.isPropertyAssignment(parent) && parent.name === node) ||
+				ts.isBindingElement(parent) ||
+				ts.isImportSpecifier(parent)
+			) {
+				return;
+			}
+			result = "unknown";
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return result;
+}
+
+function isParseLikeSchemaReceiver(identifier: TS.Identifier): boolean {
+	const access = identifier.parent;
+	let methodName: string | undefined;
+	if (ts.isPropertyAccessExpression(access) && access.expression === identifier) {
+		methodName = access.name.text;
+	} else if (ts.isElementAccessExpression(access) && access.expression === identifier) {
+		const argument = access.argumentExpression;
+		if (
+			argument !== undefined &&
+			(ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument))
+		) {
+			methodName = argument.text;
+		}
+	}
+	return (
+		methodName !== undefined &&
+		PARSE_LIKE_SCHEMA_METHODS.has(methodName) &&
+		ts.isCallExpression(access.parent) &&
+		access.parent.expression === access
+	);
 }
 
 function vendorKeyFindingsForObject(
 	source: string,
+	sourceFile: TS.SourceFile,
 	zObject: ZObjectLiteral,
+	bindings: LocalBindings,
 ): Array<{ key: string; line: number }> {
-	const keys = collectTopLevelObjectKeys(source, zObject.objectStart, zObject.objectEnd);
+	const keys = collectTopLevelObjectKeys(
+		source,
+		sourceFile,
+		zObject.objectStart,
+		zObject.objectEnd,
+		bindings,
+	);
 	const digitFamilies = new Map<string, Set<string>>();
 	for (const key of keys) {
 		const member = numberedFamilyMember(key.name);
@@ -2509,8 +3653,10 @@ function isAllowedPublicOutputKeyName(name: string): boolean {
 
 function collectTopLevelObjectKeys(
 	source: string,
+	sourceFile: TS.SourceFile,
 	objectStart: number,
 	objectEnd: number,
+	bindings: LocalBindings,
 ): Array<{ name: string; offset: number }> {
 	const keys: Array<{ name: string; offset: number }> = [];
 	const masked = maskCommentsAndStrings(source);
@@ -2532,17 +3678,16 @@ function collectTopLevelObjectKeys(
 			index = endQuote + 1;
 		} else if (masked[index] === "[") {
 			const computedEnd = findMatchingBracket(masked, index);
-			const literalStart = findNextNonWhitespace(masked, index + 1);
-			if (computedEnd === -1 || literalStart === -1) {
+			if (computedEnd === -1) {
 				break;
 			}
-			const computedQuote = source[literalStart];
-			if (computedQuote === '"' || computedQuote === "'") {
-				const literalEnd = findStringEnd(source, literalStart);
-				const afterLiteral =
-					literalEnd === -1 ? -1 : skipWhitespaceAndComments(masked, literalEnd + 1, computedEnd);
-				if (literalEnd !== -1 && afterLiteral === computedEnd) {
-					key = source.slice(literalStart + 1, literalEnd);
+			const expression = computedPropertyExpressionAtOffset(sourceFile, index);
+			if (expression !== undefined) {
+				const unwrapped = unwrapLocalExpression(expression);
+				if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped)) {
+					key = unwrapped.text;
+				} else if (ts.isIdentifier(unwrapped)) {
+					key = resolveConstStringIdentifier(unwrapped, bindings);
 				}
 			}
 			index = computedEnd + 1;
@@ -2569,6 +3714,25 @@ function collectTopLevelObjectKeys(
 	return keys;
 }
 
+function computedPropertyExpressionAtOffset(
+	sourceFile: TS.SourceFile,
+	offset: number,
+): TS.Expression | undefined {
+	let expression: TS.Expression | undefined;
+	const visit = (node: TS.Node): void => {
+		if (expression !== undefined || offset < node.getFullStart() || offset >= node.getEnd()) {
+			return;
+		}
+		if (ts.isComputedPropertyName(node) && node.getStart(sourceFile) === offset) {
+			expression = node.expression;
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return expression;
+}
+
 function findVendorTimestampLeakFindings(providerRoot: string): SourceFinding[] {
 	const findings: SourceFinding[] = [];
 	const seen = new Set<string>();
@@ -2576,6 +3740,15 @@ function findVendorTimestampLeakFindings(providerRoot: string): SourceFinding[]
 	for (const filePath of listNonTestTypeScriptFiles(providerRoot)) {
 		const source = readFileSync(filePath, "utf8");
 		const relPath = toRelativeProviderPath(providerRoot, filePath);
+		maskCommentsAndStrings(source, relPath);
+		const sourceFile = ts.createSourceFile(
+			relPath,
+			source,
+			ts.ScriptTarget.Latest,
+			true,
+			ts.ScriptKind.TS,
+		);
+		const bindings = collectLocalBindings(sourceFile);
 		const zObjectRanges = findZObjectLiterals(source).map((zObject) => ({
 			start: zObject.callStart,
 			end: zObject.objectEnd,
@@ -2588,7 +3761,7 @@ function findVendorTimestampLeakFindings(providerRoot: string): SourceFinding[]
 		].filter((range) => rangeContainedInRanges(fixtureRanges, range));
 
 		for (const range of fixtureResponseRanges) {
-			for (const literal of findStringLiteralsInRange(source, range)) {
+			for (const literal of findStringLiteralsInRange(source, range, relPath)) {
 				if (
 					rangeContainsOffset(zObjectRanges, literal.offset) ||
 					rangeContainsOffset(upstreamRanges, literal.offset) ||
@@ -2609,12 +3782,86 @@ function findVendorTimestampLeakFindings(providerRoot: string): SourceFinding[]
 					}
 				}
 			}
+
+			const visitAliases = (node: TS.Node): void => {
+				if (findings.length >= MAX_SOURCE_FINDING_EVIDENCE) {
+					return;
+				}
+				const offset = node.getStart(sourceFile);
+				if (
+					ts.isIdentifier(node) &&
+					isIdentifierValueUse(node) &&
+					offset >= range.start &&
+					offset <= range.end &&
+					!rangeContainsOffset(zObjectRanges, offset) &&
+					!rangeContainsOffset(upstreamRanges, offset)
+				) {
+					const value = resolveConstStringIdentifier(node, bindings);
+					if (
+						value !== undefined &&
+						isVendorTimestampCandidate(value, propertyNameForValueExpression(node))
+					) {
+						const line = offsetToLine(source, offset);
+						const key = `${relPath}:${line}:${value}`;
+						if (!seen.has(key)) {
+							seen.add(key);
+							findings.push({ file: relPath, line });
+						}
+					}
+				}
+				ts.forEachChild(node, visitAliases);
+			};
+			visitAliases(sourceFile);
+			if (findings.length >= MAX_SOURCE_FINDING_EVIDENCE) {
+				return findings;
+			}
 		}
 	}
 
 	return findings;
 }
 
+function isIdentifierValueUse(identifier: TS.Identifier): boolean {
+	const parent = identifier.parent;
+	return !(
+		(ts.isPropertyAssignment(parent) && parent.name === identifier) ||
+		(ts.isPropertyAccessExpression(parent) && parent.name === identifier) ||
+		ts.isBindingElement(parent) ||
+		ts.isVariableDeclaration(parent) ||
+		ts.isParameter(parent) ||
+		ts.isImportClause(parent) ||
+		ts.isImportSpecifier(parent) ||
+		ts.isNamespaceImport(parent) ||
+		ts.isFunctionDeclaration(parent) ||
+		ts.isFunctionExpression(parent) ||
+		ts.isClassDeclaration(parent) ||
+		ts.isClassExpression(parent) ||
+		ts.isPropertyDeclaration(parent) ||
+		ts.isPropertySignature(parent) ||
+		ts.isMethodDeclaration(parent) ||
+		ts.isMethodSignature(parent)
+	);
+}
+
+function propertyNameForValueExpression(expression: TS.Expression): string | undefined {
+	let current: TS.Expression = expression;
+	while (
+		ts.isParenthesizedExpression(current.parent) ||
+		ts.isAsExpression(current.parent) ||
+		ts.isSatisfiesExpression(current.parent) ||
+		ts.isNonNullExpression(current.parent)
+	) {
+		current = current.parent;
+	}
+	if (ts.isPropertyAssignment(current.parent) && current.parent.initializer === current) {
+		return propertyNameText(current.parent.name);
+	}
+	if (ts.isShorthandPropertyAssignment(current.parent)) {
+		return current.parent.name.text;
+	}
+	return undefined;
+}
+
 function findPropertyObjectRanges(source: string, propertyName: string): ObjectRange[] {
 	const ranges: ObjectRange[] = [];
 	const masked = maskCommentsAndStrings(source);
@@ -2658,23 +3905,16 @@ function findNamedConstValueRanges(source: string): NamedObjectRange[] {
 	return ranges;
 }
 
-function findConstValueRangeContaining(
-	source: string,
-	offset: number,
-): NamedObjectRange | undefined {
-	return findNamedConstValueRanges(source).find(
-		(range) => offset >= range.start && offset <= range.end,
-	);
-}
-
 function findStringLiteralsInRange(
 	source: string,
 	range: ObjectRange,
+	fileName: string,
 ): Array<{ value: string; offset: number }> {
 	const literals: Array<{ value: string; offset: number }> = [];
+	const masked = maskCommentsAndStrings(source, fileName);
 	let index = range.start;
 	while (index <= range.end) {
-		const quote = source[index];
+		const quote = masked[index];
 		if (quote !== '"' && quote !== "'" && quote !== "`") {
 			index += 1;
 			continue;
@@ -2784,57 +4024,199 @@ function findStringEnd(source: string, start: number): number {
 	return -1;
 }
 
-function maskCommentsAndStrings(source: string): string {
-	const chars = source.split("");
-	for (let index = 0; index < source.length; index += 1) {
-		if (source.startsWith("//", index)) {
-			const bodyStart = index + 2;
-			const newline = source.indexOf("\n", bodyStart);
-			const end = newline === -1 ? source.length : newline;
-			for (let bodyIndex = bodyStart; bodyIndex < end; bodyIndex += 1) {
-				chars[bodyIndex] = " ";
-			}
-			index = end;
-			continue;
+// Masking now parses with TypeScript, which is orders of magnitude more
+// expensive than the character walk it replaced, and six scanners call this
+// helper once per candidate match — the same file is masked thousands of
+// times in one run (measured: 1,872 calls for a 3.4k-line provider). Without
+// memoization that run regresses from ~8s to minutes and can exceed the CI
+// validation timeout. Successful results are cached by exact source text and
+// property-key mode; the cache stays small because a run only ever reads a
+// handful of files.
+// Parse failures are NOT cached: they throw and abort the check (fail-closed).
+const MASK_CACHE_LIMIT = 64;
+const maskCache = new Map<string, string>();
+
+// Neutralize { } ( ) [ ], backtick, quotes, slash, backslash, comma, and semicolon
+// because scanners treat these as depth, string/regex delimiters, or top-level stops.
+const PRESERVED_PROPERTY_KEY_STRUCTURAL_CHARS = new Set([
+	"{",
+	"}",
+	"(",
+	")",
+	"[",
+	"]",
+	"`",
+	'"',
+	"'",
+	"/",
+	"\\",
+	",",
+	";",
+]);
+
+type MaskCommentsAndStringsOptions = {
+	blankPropertyKeys?: boolean;
+};
+
+export function maskCommentsAndStrings(
+	source: string,
+	fileName = "provider.ts",
+	options: MaskCommentsAndStringsOptions = {},
+): string {
+	const blankPropertyKeys = options.blankPropertyKeys === true;
+	const cacheKey = `${blankPropertyKeys ? "blank-keys" : "preserve-keys"}\0${source}`;
+	const cached = maskCache.get(cacheKey);
+	if (cached !== undefined) {
+		return cached;
+	}
+	const masked = computeMaskedSource(source, fileName, blankPropertyKeys);
+	if (maskCache.size >= MASK_CACHE_LIMIT) {
+		const oldest = maskCache.keys().next();
+		if (!oldest.done) {
+			maskCache.delete(oldest.value);
 		}
-		if (source.startsWith("/*", index)) {
-			const bodyStart = index + 2;
-			const close = source.indexOf("*/", bodyStart);
-			const end = close === -1 ? source.length : close;
-			for (let bodyIndex = bodyStart; bodyIndex < end; bodyIndex += 1) {
-				if (chars[bodyIndex] !== "\n") {
-					chars[bodyIndex] = " ";
-				}
+	}
+	maskCache.set(cacheKey, masked);
+	return masked;
+}
+
+function computeMaskedSource(
+	source: string,
+	fileName: string,
+	blankPropertyKeys: boolean,
+): string {
+	const transpiled = ts.transpileModule(source, {
+		// Declaration files trigger an internal TypeScript Debug Failure when
+		// passed to transpileModule. Parsing is all we need here, so always use a
+		// synthetic implementation filename while retaining the real filename
+		// for source mapping and sanitized diagnostics below.
+		fileName: "provider.ts",
+		reportDiagnostics: true,
+		compilerOptions: { target: ts.ScriptTarget.Latest },
+	});
+	const sourceFile = ts.createSourceFile(
+		fileName,
+		source,
+		ts.ScriptTarget.Latest,
+		true,
+		ts.ScriptKind.TS,
+	);
+	const parseDiagnostic = transpiled.diagnostics?.[0];
+	if (parseDiagnostic) {
+		const position = parseDiagnostic.start ?? 0;
+		const { line, character } = sourceFile.getLineAndCharacterOfPosition(position);
+		throw new Error(
+			`Cannot safely scan TypeScript source ${sanitizeDiagnosticFileName(fileName)} at ${line + 1}:${character + 1}: ${ts.flattenDiagnosticMessageText(parseDiagnostic.messageText, "\n")}`,
+		);
+	}
+
+	const chars = source.split("");
+	const maskRange = (start: number, end: number): void => {
+		for (let index = start; index < end; index += 1) {
+			// Preserve the backslash of a string line continuation (\ followed
+			// by LF, CRLF, or lone CR) and every line terminator, so masked
+			// string bodies remain syntactically valid and the mask output can
+			// be re-parsed (mask(mask(x)) === mask(x)).
+			if (
+				source[index] === "\\" &&
+				(source[index + 1] === "\n" || source[index + 1] === "\r")
+			) {
+				continue;
 			}
-			index = close === -1 ? source.length : close + 1;
-			continue;
-		}
-		const quote = source[index];
-		if (quote !== '"' && quote !== "'" && quote !== "`") {
-			continue;
-		}
-		const end = findStringEnd(source, index);
-		if (end === -1) {
-			break;
+			if (chars[index] !== "\n" && chars[index] !== "\r") chars[index] = " ";
 		}
-		// Preserve quoted property keys ("response": ...) so range/key scanners
-		// can still match them; only string VALUES are blanked.
-		let probe = end + 1;
-		while (probe < source.length && /\s/.test(source[probe] ?? "")) {
-			probe += 1;
+	};
+	const commentRanges = new Map<string, TS.CommentRange>();
+	const addCommentRanges = (ranges: readonly TS.CommentRange[] | undefined): void => {
+		for (const range of ranges ?? []) {
+			commentRanges.set(`${range.pos}:${range.end}`, range);
 		}
-		if (source[probe] !== ":") {
-			for (let bodyIndex = index + 1; bodyIndex < end; bodyIndex += 1) {
-				if (chars[bodyIndex] !== "\n") {
-					chars[bodyIndex] = " ";
+	};
+
+	const visit = (node: TS.Node): void => {
+		addCommentRanges(ts.getLeadingCommentRanges(source, node.getFullStart()));
+		addCommentRanges(ts.getTrailingCommentRanges(source, node.getEnd()));
+
+		const start = node.getStart(sourceFile);
+		if (ts.isStringLiteral(node)) {
+			// Preserve quoted property keys ("response": ...) by default so range/key
+			// scanners can still match them. Line scanners opt into blanking key bodies
+			// as well, preventing key text from looking like executable source.
+			const isQuotedPropertyKey =
+				ts.isPropertyAssignment(node.parent) && node.parent.name === node;
+			if (blankPropertyKeys || !isQuotedPropertyKey) {
+				maskRange(start + 1, node.end - 1);
+			} else {
+				for (let index = start + 1; index < node.end - 1; index += 1) {
+					if (
+						source[index] === "\\" &&
+						(source[index + 1] === "\n" || source[index + 1] === "\r")
+					) {
+						continue;
+					}
+					if (PRESERVED_PROPERTY_KEY_STRUCTURAL_CHARS.has(source[index] ?? "")) {
+						chars[index] = " ";
+					}
 				}
 			}
-		}
-		index = end;
+		} else if (ts.isRegularExpressionLiteral(node)) {
+			let closeDelimiter = node.end - 1;
+			while (closeDelimiter > start && /[A-Za-z]/.test(source[closeDelimiter] ?? "")) {
+				closeDelimiter -= 1;
+			}
+			maskRange(start + 1, closeDelimiter);
+		} else if (ts.isNoSubstitutionTemplateLiteral(node)) {
+			maskRange(start + 1, node.end - 1);
+		} else if (node.kind === ts.SyntaxKind.TemplateHead) {
+			maskRange(start + 1, node.end - 2);
+		} else if (node.kind === ts.SyntaxKind.TemplateMiddle) {
+			maskRange(start + 1, node.end - 2);
+		} else if (node.kind === ts.SyntaxKind.TemplateTail) {
+			maskRange(start + 1, node.end - 1);
+		}
+
+		for (const child of node.getChildren(sourceFile)) visit(child);
+	};
+
+	visit(sourceFile);
+	for (const comment of commentRanges.values()) {
+		const markerLength = 2;
+		const bodyEnd =
+			comment.kind === ts.SyntaxKind.MultiLineCommentTrivia
+				? comment.end - markerLength
+				: comment.end;
+		maskRange(comment.pos + markerLength, bodyEnd);
 	}
 	return chars.join("");
 }
 
+// Escapes every non-printable or formatting character before a submitter-
+// controlled filename is interpolated into a diagnostic that the CLI prints.
+// Category-based on purpose: enumerated code-point lists kept missing members
+// of the same class (C1 controls, U+061C, U+2028/U+2029 were each found
+// individually in review), so this escapes the whole Unicode categories —
+// Cc (controls), Cf (formatting, includes all Bidi_Control), Zl/Zp
+// (line/paragraph separators). Ordinary letters, digits, spaces, and CJK
+// filenames pass through unchanged.
+const DIAGNOSTIC_UNSAFE_CHARACTER = /\p{Cc}|\p{Cf}|\p{Zl}|\p{Zp}/u;
+
+function sanitizeDiagnosticFileName(fileName: string): string {
+	let sanitized = "";
+	for (const character of fileName) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint === undefined) continue;
+		if (DIAGNOSTIC_UNSAFE_CHARACTER.test(character)) {
+			sanitized +=
+				codePoint <= 0xff
+					? `\\x${codePoint.toString(16).padStart(2, "0")}`
+					: `\\u{${codePoint.toString(16)}}`;
+		} else {
+			sanitized += character;
+		}
+	}
+	return sanitized;
+}
+
 function skipWhitespaceAndComments(source: string, start: number, end: number): number {
 	let index = start;
 	while (index < end) {
@@ -4229,8 +5611,9 @@ function shannonEntropy(value: string): number {
 
 function guessSecretName(line: string): string {
 	const match =
-		/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)/.exec(line) ??
-		/["']?([A-Za-z_$][\w$-]*)["']?\s*:/.exec(line);
+		/\b[A-Za-z_$][\w$]*(?:\s*\.\s*([A-Za-z_$][\w$]*))+\s*=/.exec(line) ??
+		/["']?([A-Za-z_$][\w$-]*)["']?\s*:\s*["'`]/.exec(line) ??
+		/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)/.exec(line);
 	const raw = match?.[1] ?? "SECRET";
 	return raw
 		.replace(/([a-z0-9])([A-Z])/g, "$1_$2")
@@ -4245,6 +5628,35 @@ const SECRETISH_IDENTIFIER_PATTERN = /key|token|secret|password|credential|auth/
 // the three stay coherent.
 const ENTROPY_CANDIDATE_MIN_LENGTH = 20;
 
+// A secret-ish name is only supporting evidence. Shorter values must also look
+// credential-like, and known config tokens/numeric values are never candidates.
+const SECRET_NAMED_ENV_VALUE_MIN_LENGTH = 4;
+const SECRET_NAMED_ENV_UNSTRUCTURED_MIN_LENGTH = 8;
+const NON_SECRET_ENV_VALUE_TOKENS = new Set([
+	"true",
+	"false",
+	"yes",
+	"no",
+	"on",
+	"off",
+	"none",
+	"null",
+	"nil",
+	"auto",
+	"default",
+	"local",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"always",
+	"never",
+	"enabled",
+	"disabled",
+	"0",
+	"1",
+]);
+
 const SECRET_PATTERNS: Array<[string, RegExp]> = [
 	["JWT-like token", /eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}/],
 	["GitHub token", /gh[pousr]_[A-Za-z0-9_]{30,}/],
@@ -4256,12 +5668,151 @@ const SECRET_PATTERNS: Array<[string, RegExp]> = [
 	],
 ];
 
-async function safeLoadProvider(providerRoot: string): Promise<ProviderDefinition | undefined> {
+type SafeLoadProviderResult =
+	| { ok: true; provider: ProviderDefinition | undefined }
+	| { ok: false; error: unknown };
+
+async function safeLoadProvider(providerRoot: string): Promise<SafeLoadProviderResult> {
+	try {
+		return { ok: true, provider: await loadProvider(providerRoot) };
+	} catch (error) {
+		return { ok: false, error };
+	}
+}
+
+const UNRENDERABLE_LOAD_ERROR = "<thrown value could not be rendered>";
+
+function formatLoadErrorEvidence(error: unknown, providerRoot: string): string[] {
+	const evidence: string[] = [];
+	const seen = new Set<object>();
+	let current: unknown = error;
+	let frame = 0;
+	while (frame < MAX_LOAD_ERROR_EVIDENCE) {
+		if (typeof current === "object" || typeof current === "function") {
+			if (current !== null && seen.has(current)) {
+				break;
+			}
+			if (current !== null) seen.add(current);
+		}
+		evidence.push(
+			`${frame === 0 ? "Load error" : "Cause"}: ${sanitizeLoadErrorText(
+				formatThrownValue(current),
+				providerRoot,
+			)}`,
+		);
+		frame += 1;
+		const cause = readThrownValueCause(current);
+		if (!cause.found || cause.value === undefined || cause.value === null) {
+			break;
+		}
+		current = cause.value;
+	}
+	return evidence;
+}
+
+function formatThrownValue(value: unknown): string {
 	try {
-		return await loadProvider(providerRoot);
+		if (value instanceof Error) {
+			return String(value.message);
+		}
+		if (
+			value !== null &&
+			(typeof value === "object" || typeof value === "function") &&
+			"message" in value
+		) {
+			return String((value as { message?: unknown }).message);
+		}
+		return `<non-Error value thrown: ${String(value)}>`;
 	} catch {
-		return undefined;
+		return UNRENDERABLE_LOAD_ERROR;
+	}
+}
+
+function readThrownValueCause(value: unknown): { found: boolean; value?: unknown } {
+	try {
+		if (
+			value === null ||
+			(typeof value !== "object" && typeof value !== "function") ||
+			!("cause" in value)
+		) {
+			return { found: false };
+		}
+		return { found: true, value: (value as { cause?: unknown }).cause };
+	} catch {
+		return { found: false };
+	}
+}
+
+function isPlausibleSecretNamedEnvValue(value: string): boolean {
+	const normalized = value.trim();
+	if (normalized.length < SECRET_NAMED_ENV_VALUE_MIN_LENGTH) return false;
+	if (NON_SECRET_ENV_VALUE_TOKENS.has(normalized.toLowerCase())) return false;
+	if (/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(normalized)) return false;
+	if (normalized.length >= SECRET_NAMED_ENV_UNSTRUCTURED_MIN_LENGTH) return true;
+
+	const hasLetter = /[A-Za-z]/.test(normalized);
+	const hasDigitOrSymbol = /[^A-Za-z\s]/.test(normalized);
+	return hasLetter && hasDigitOrSymbol;
+}
+
+function replaceEnvValue(
+	input: string,
+	value: string,
+	requireIdentifierBoundaries: boolean,
+): string {
+	if (!requireIdentifierBoundaries) return input.replaceAll(value, "[REDACTED]");
+	const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return input.replace(
+		new RegExp(`(?<![A-Za-z0-9_])${escaped}(?![A-Za-z0-9_])`, "g"),
+		"[REDACTED]",
+	);
+}
+
+function sanitizeLoadErrorText(value: string, providerRoot: string): string {
+	let output = value.replace(
+		/(^|[^A-Za-z0-9_.])((?:\/[^\s"'`]+)+)/g,
+		(_match, prefix: string, rawPath: string) => {
+			const pathCandidate = rawPath.replace(/[),.;:!?]+$/u, "");
+			const relativePath = relative(providerRoot, resolve(pathCandidate));
+			const insideProvider =
+				relativePath === "" ||
+				(relativePath !== ".." && !relativePath.startsWith(`..${sep}`));
+			return `${prefix}${insideProvider ? relativePath || "." : "[REDACTED_PATH]"}`;
+		},
+	);
+	output = output.replace(/[A-Za-z]:[\\/][^\s"'`]+/g, "[REDACTED_PATH]");
+	output = output.replace(
+		/((?:password|token|secret|api[_-]?key|credential|authorization)\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|["'`]?[^\s,;"'`]+)/gi,
+		"$1[REDACTED]",
+	);
+	const envValues: Array<{ value: string; requireIdentifierBoundaries: boolean }> = [];
+	for (const [name, item] of Object.entries(process.env)) {
+		if (typeof item !== "string") continue;
+		const secretNamed = SECRETISH_IDENTIFIER_PATTERN.test(name);
+		let shouldRedact = secretNamed;
+		if (secretNamed) {
+			shouldRedact = isPlausibleSecretNamedEnvValue(item);
+		} else if (item.length >= ENTROPY_CANDIDATE_MIN_LENGTH && shouldConsiderEntropyValue(item)) {
+			const charset = classifyEntropyCharset(item);
+			const threshold = charset === "hex" ? 3.0 : 4.5;
+			shouldRedact = charset !== undefined && shannonEntropy(item) >= threshold;
+		}
+		if (shouldRedact) {
+			envValues.push({
+				value: item,
+				requireIdentifierBoundaries:
+					secretNamed && item.trim().length < ENTROPY_CANDIDATE_MIN_LENGTH,
+			});
+		}
+	}
+	envValues.sort((a, b) => b.value.length - a.value.length);
+	for (const envValue of envValues) {
+		output = replaceEnvValue(output, envValue.value, envValue.requireIdentifierBoundaries);
 	}
+	output = redact(output).replace(/\s+/g, " ");
+	return output.length > MAX_LOAD_ERROR_MESSAGE_LENGTH
+		? `${output.slice(0, MAX_LOAD_ERROR_MESSAGE_LENGTH - 1)}…`
+		: output;
 }
 
 async function loadProvider(providerRoot: string): Promise<ProviderDefinition | undefined> {