octane 0.2.11 → 0.2.13

package/dist/compiler/native-attribute-reads.js

@@ -0,0 +1,127 @@
+// Direct native bindings recognize capability syntax, not structural `.get`
+// methods. Share this syntax boundary between runtime and virtual TSX lowering.
+function unwrapExpression(node) {
+	while (
+		node &&
+		(node.type === 'TSAsExpression' ||
+			node.type === 'TSTypeAssertion' ||
+			node.type === 'TSNonNullExpression' ||
+			node.type === 'TSSatisfiesExpression' ||
+			node.type === 'TSInstantiationExpression' ||
+			node.type === 'ChainExpression' ||
+			node.type === 'ParenthesizedExpression')
+	) {
+		node = node.expression;
+	}
+	return node;
+}
+
+export function isDirectSignalHandleExpression(node) {
+	node = unwrapExpression(node);
+	if (!node) return false;
+	if (node.type === 'Identifier') return node.name.endsWith('$');
+	if (node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') {
+		const name = node.computed
+			? node.property?.type === 'Literal' && typeof node.property.value === 'string'
+				? node.property.value
+				: null
+			: node.property?.name;
+		return typeof name === 'string' && name.endsWith('$');
+	}
+	if (node.type === 'CallExpression' || node.type === 'OptionalCallExpression') {
+		const callee = unwrapExpression(node.callee);
+		const name =
+			callee?.type === 'Identifier'
+				? callee.name
+				: callee?.type === 'MemberExpression' || callee?.type === 'OptionalMemberExpression'
+					? callee.computed
+						? callee.property?.value
+						: callee.property?.name
+					: null;
+		return /^_?\$?__(?:signal|derived|query)At$/.test(name ?? '');
+	}
+	return false;
+}
+
+function rejectNestedHandles(node) {
+	if (!node || typeof node !== 'object') return;
+	if (isDirectSignalHandleExpression(node))
+		throw new Error(
+			'Native JSX signal projections do not support handles inside callbacks, constructors, or tagged templates.',
+		);
+	for (const key of Object.keys(node)) {
+		if (!['metadata', 'loc', 'start', 'end'].includes(key)) rejectNestedHandles(node[key]);
+	}
+}
+
+/** Only an explicitly configured native attribute admits these sampled reads. */
+export function lowerNativeAttributeReads(expression, read) {
+	let reactive = false;
+	const rewrite = (node) => {
+		if (!node || typeof node !== 'object') return node;
+		if (Array.isArray(node)) return node.map(rewrite);
+		if (isDirectSignalHandleExpression(node)) {
+			reactive = true;
+			return read(node);
+		}
+		if (node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') {
+			if (isDirectSignalHandleExpression(node.object))
+				throw new Error(
+					'Native JSX signal projections require .get() before reading a signal payload property.',
+				);
+			return {
+				...node,
+				object: rewrite(node.object),
+				property: node.computed ? rewrite(node.property) : node.property,
+			};
+		}
+		if (node.type === 'CallExpression' || node.type === 'OptionalCallExpression') {
+			const callee = unwrapExpression(node.callee);
+			const handleGet =
+				(callee?.type === 'MemberExpression' || callee?.type === 'OptionalMemberExpression') &&
+				(callee.computed ? callee.property?.value : callee.property?.name) === 'get' &&
+				isDirectSignalHandleExpression(callee.object);
+			if (handleGet) reactive = true;
+			return {
+				...node,
+				// Keep a method call as a member call so `this` and evaluation order
+				// survive a computed style selection. Explicit get keeps its receiver.
+				callee:
+					!handleGet &&
+					(callee?.type === 'MemberExpression' || callee?.type === 'OptionalMemberExpression')
+						? rewrite(node.callee)
+						: node.callee,
+				arguments: node.arguments.map(rewrite),
+			};
+		}
+		if (
+			[
+				'FunctionExpression',
+				'ArrowFunctionExpression',
+				'ClassExpression',
+				'NewExpression',
+				'TaggedTemplateExpression',
+			].includes(node.type)
+		) {
+			rejectNestedHandles(node);
+			return node;
+		}
+		if (node.type === 'Property') {
+			const value = rewrite(node.value);
+			return value === node.value ? node : { ...node, value, shorthand: false };
+		}
+		let result = node;
+		for (const key of Object.keys(node)) {
+			if (['metadata', 'loc', 'start', 'end'].includes(key)) continue;
+			const value = node[key];
+			if (!value || typeof value !== 'object') continue;
+			const next = rewrite(value);
+			if (next !== value) {
+				if (result === node) result = { ...node };
+				result[key] = next;
+			}
+		}
+		return result;
+	};
+	return { expression: rewrite(expression), reactive };
+}

package/dist/compiler/native-change-diagnostics.js

@@ -1,6 +1,6 @@
 import { builders as b } from '@tsrx/core';
 import { nsForChildren, nsForSelf } from './jsx-namespace.js';
-import { analyzeRendererBoundaries } from './renderer-boundaries.js';
+import { createRendererRegionResolver } from './renderer-boundaries.js';
 
 export const NATIVE_TEXT_ONCHANGE_DIAGNOSTIC = 'OCTANE_NATIVE_TEXT_ONCHANGE';
 
@@ -263,15 +263,16 @@ function hostLabel(tag, type) {
 	return tag === 'textarea' ? '<textarea>' : `<input type="${type.display}">`;
 }
 
-function diagnosticFor(source, filename, tag, type, changeAttributes, controlled) {
+function diagnosticFor(source, filename, tag, type, changeAttributes, controlled, strong) {
 	const first = changeAttributes[0];
 	const captureOnly = attributeName(first) === 'onChangeCapture';
 	const replacement = captureOnly ? 'onInputCapture' : 'onInput';
 	let message =
 		`[${NATIVE_TEXT_ONCHANGE_DIAGNOSTIC}] \`${attributeName(first)}\` on ${hostLabel(tag, type)} ` +
 		`is a native commit event in Octane; it does not run for each text edit. Use \`${replacement}\` ` +
-		'for per-edit updates. If commit/blur behavior is intentional, add ' +
-		'`suppressNativeChangeWarning`.';
+		(strong
+			? 'for per-edit updates. Strong mode requires an explicit per-edit handler for editable text controls.'
+			: 'for per-edit updates. If commit/blur behavior is intentional, add `suppressNativeChangeWarning`.');
 	if (controlled) {
 		message +=
 			' This control also has `value`; edits are restored before the later native change. ' +
@@ -280,7 +281,7 @@ function diagnosticFor(source, filename, tag, type, changeAttributes, controlled
 	const primary = rangeFor(source, first.name ?? first);
 	return {
 		code: NATIVE_TEXT_ONCHANGE_DIAGNOSTIC,
-		severity: 'warning',
+		severity: strong ? 'error' : 'warning',
 		message,
 		filename: filename || 'module.tsrx',
 		start: primary.start,
@@ -295,7 +296,16 @@ function diagnosticFor(source, filename, tag, type, changeAttributes, controlled
 	};
 }
 
-function classifyHost(node, scope, namespace, source, filename, diagnostics, classifications) {
+function classifyHost(
+	node,
+	scope,
+	namespace,
+	source,
+	filename,
+	diagnostics,
+	classifications,
+	strong,
+) {
 	const tag = tagName(node);
 	if ((tag !== 'input' && tag !== 'textarea') || namespace !== 'html') return;
 	const attributes = attributesOf(node);
@@ -365,6 +375,7 @@ function classifyHost(node, scope, namespace, source, filename, diagnostics, cla
 			type ?? { kind: 'text', display: 'text' },
 			changeAttributes,
 			lastAttribute(attributes, 'value') !== null,
+			strong,
 		),
 	);
 }
@@ -377,41 +388,15 @@ function classifyHost(node, scope, namespace, source, filename, diagnostics, cla
 export function analyzeNativeChangeDiagnostics(ast, source, filename, options = {}) {
 	// The parser permits trivia after `<` and Unicode escapes in JSX names. A
 	// decoded lowercase input/textarea must still leave either its literal name
-	// or a backslash in the paired authored source. False positives only retain
+	// or a Unicode escape in the paired authored source. False positives only retain
 	// the existing analysis for unrelated identifiers, comments, and strings.
-	if (!source.includes('input') && !source.includes('textarea') && !source.includes('\\')) {
+	if (!source.includes('input') && !source.includes('textarea') && !source.includes('\\u')) {
 		return { diagnostics: [], classifications: new Map() };
 	}
 	const diagnostics = [];
 	const classifications = new Map();
-	const ownerRendererId = options.renderer?.id ?? (options.dom === false ? null : 'dom');
-	let rendererRegions = [];
-	if (options.rendererBoundaries && Object.keys(options.rendererBoundaries).length > 0) {
-		rendererRegions = analyzeRendererBoundaries(source, {
-			filename,
-			rendererBoundaries: options.rendererBoundaries,
-		})
-			.boundaries.map((boundary) => ({
-				childRenderer: boundary.childRenderer,
-				range: boundary.region?.range ?? boundary.region?.valueRange,
-			}))
-			.filter((region) => region.range !== null);
-	}
-	const rendererIsDomAt = (node) => {
-		let rendererId = ownerRendererId;
-		let narrowest = Number.POSITIVE_INFINITY;
-		for (const region of rendererRegions) {
-			const [start, end] = region.range;
-			if (start > node.start || node.end > end) continue;
-			const width = end - start;
-			if (width < narrowest) {
-				rendererId = region.childRenderer;
-				narrowest = width;
-			}
-		}
-		if (rendererId === 'dom') return true;
-		return options.rendererRegistry?.[rendererId]?.target === 'dom';
-	};
+	const rendererIsDomAt =
+		options.rendererRegionResolver ?? createRendererRegionResolver(ast, source, filename, options);
 
 	const programScope = createScope(null, ast?.body ?? []);
 	const seen = new WeakSet();
@@ -484,7 +469,16 @@ export function analyzeNativeChangeDiagnostics(ast, source, filename, options =
 		const isHost = typeof tag === 'string' && /^[a-z]/.test(tag);
 		const selfNs = isHost ? nsForSelf(tag, parentNs) : parentNs;
 		if (isHost && rendererIsDomAt(node)) {
-			classifyHost(node, scope, selfNs, source, filename, diagnostics, classifications);
+			classifyHost(
+				node,
+				scope,
+				selfNs,
+				source,
+				filename,
+				diagnostics,
+				classifications,
+				options.strong === true,
+			);
 		}
 
 		for (const attribute of attributesOf(node)) {
@@ -508,5 +502,5 @@ export function analyzeNativeChangeDiagnostics(ast, source, filename, options =
 }
 
 export function formatCompileDiagnostic(diagnostic) {
-	return `${diagnostic.filename}:${diagnostic.start.line}:${diagnostic.start.column + 1} ${diagnostic.message}`;
+	return `${diagnostic.filename}:${diagnostic.start.line}:${diagnostic.start.column + 1} ${diagnostic.severity}: ${diagnostic.message}`;
 }

package/dist/compiler/native-read-diagnostics.js

@@ -5,9 +5,11 @@ export { NATIVE_SIGNAL_NAME, NATIVE_MEMO_READ } from './native-read-facts.js';
 
 const SIGNALS_MODULE = 'octane/signals';
 const CLIENT_MODULE = 'octane/signals/client';
+const SIGNAL_MODULES = new Set([SIGNALS_MODULE, CLIENT_MODULE, 'octane/signals/server']);
 const LOCAL_MODULES = new Set([CLIENT_MODULE, 'octane/signals/server']);
 const HANDLE_TYPES = new Set(['SignalHandle', 'Resource', 'WritableSignal', 'DerivedSignal']);
-const SIGNAL_METHODS = new Set(['signal$', 'derived$', 'asyncSignal$']);
+const SIGNAL_METHODS = new Set(['signal$', 'derived$']);
+const SIGNAL_FACTORIES = new Set(['signal$', 'derived$', 'query$', 'createResource']);
 const LOCAL_HOOKS = new Set(['useSignal$']);
 const FUNCTION_TYPES = new Set([
 	'ArrowFunctionExpression',
@@ -189,8 +191,12 @@ export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}
 		}
 	}
 	function importedValue(module, name) {
+		if (module === 'octane/behavior' && (name === 'adoptBindings' || name === 'mountBindings'))
+			return { kind: 'builtin', name, bindingSource: true };
 		if (module === SIGNALS_MODULE && name === 'createScope')
 			return { kind: 'builtin', name: 'createScope' };
+		if (SIGNAL_MODULES.has(module) && SIGNAL_FACTORIES.has(name))
+			return { kind: 'builtin', name, capability: true };
 		if (LOCAL_MODULES.has(module) && name === 'useDerived$')
 			return { kind: 'unsupportedHook', name };
 		if (LOCAL_MODULES.has(module) && LOCAL_HOOKS.has(name))
@@ -382,7 +388,12 @@ export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}
 			if (callee.kind === 'function') return callee.result;
 			if (callee.kind === 'builtin') {
 				if (callee.name === 'createScope') return SCOPE;
-				if (SIGNAL_METHODS.has(callee.name) || LOCAL_HOOKS.has(callee.name)) return HANDLE;
+				if (
+					SIGNAL_METHODS.has(callee.name) ||
+					SIGNAL_FACTORIES.has(callee.name) ||
+					LOCAL_HOOKS.has(callee.name)
+				)
+					return HANDLE;
 			}
 			return UNKNOWN;
 		}
@@ -464,6 +475,16 @@ export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}
 			}
 		}
 	} while (changed);
+	// BindingSource uses a fixed protocol key even when its snapshot carries
+	// native handles. Exempt only callbacks reached through the source argument
+	// of a directly imported bindings API, never arbitrary getSnapshot methods.
+	const bindingSnapshots = new WeakSet();
+	for (const node of nodes) {
+		if (node.type !== 'CallExpression' && node.type !== 'OptionalCallExpression') continue;
+		if (recordFor(unwrap(node.callee))?.forced?.bindingSource !== true) continue;
+		const snapshot = memberValue(valueOf(node.arguments[2]), 'getSnapshot');
+		if (snapshot.kind === 'function') bindingSnapshots.add(snapshot.fn);
+	}
 	function containsHandle(value, active = new Set()) {
 		if (value.kind === 'handle') return true;
 		if (value.kind !== 'object' || active.has(value)) return false;
@@ -510,9 +531,45 @@ export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}
 			`Native signal handles and functions exposing handles or live reads must end in $. Rename ${JSON.stringify(name)} to ${JSON.stringify(name + '$')}; sampled values keep ordinary names.`,
 		);
 	}
+	function createsCapability(node, value) {
+		node = unwrap(node);
+		if (!node || !isCapability(value)) return false;
+		return (
+			node.type === 'CallExpression' ||
+			node.type === 'OptionalCallExpression' ||
+			FUNCTION_TYPES.has(node.type)
+		);
+	}
+	function isDomStyleProperty(node) {
+		let object = parents.get(node);
+		let container = parents.get(object);
+		while (
+			container &&
+			(WRAPPERS.has(container.type) ||
+				(container.type === 'LogicalExpression' &&
+					(container.operator !== '&&' || container.right === object)) ||
+				(container.type === 'ConditionalExpression' &&
+					(container.consequent === object || container.alternate === object)))
+		) {
+			object = container;
+			container = parents.get(object);
+		}
+		if (container?.type !== 'JSXExpressionContainer') return false;
+		const attribute = parents.get(container);
+		if (attribute?.type !== 'JSXAttribute' || attribute.name?.name !== 'style') return false;
+		const opening = parents.get(attribute);
+		const tag = opening?.name;
+		return tag?.type === 'JSXIdentifier' && /^[a-z]/.test(tag.name);
+	}
 	for (const record of allRecords) {
 		const value = recordValue(record);
-		for (const declaration of record.declarations) checkName(declaration, record.name, value);
+		if (
+			record.expressions.some(({ expression }) =>
+				createsCapability(expression, valueOf(expression)),
+			)
+		) {
+			for (const declaration of record.declarations) checkName(declaration, record.name, value);
+		}
 	}
 	for (const node of nodes) {
 		if (
@@ -526,13 +583,17 @@ export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}
 				'useDerived$ is not available. Create derived$ on an explicitly owned Scope and pass the handle to the component.',
 			);
 		} else if (node.type === 'Property' && parents.get(node)?.type === 'ObjectExpression') {
-			checkName(node.key, propertyName(node.key, node.computed), valueOf(node.value));
+			const value = valueOf(node.value);
+			const bindingSnapshot =
+				propertyName(node.key, node.computed) === 'getSnapshot' &&
+				bindingSnapshots.has(unwrap(node.value));
+			if (!isDomStyleProperty(node) && !bindingSnapshot && createsCapability(node.value, value))
+				checkName(node.key, propertyName(node.key, node.computed), value);
 		} else if (node.type === 'AssignmentExpression' && node.operator === '=') {
 			const left = unwrap(node.left);
-			if (left?.type === 'MemberExpression')
-				checkName(left.property, propertyName(left.property, left.computed), valueOf(node.right));
-		} else if (node.type === 'ExportSpecifier' && parents.get(node)?.source == null) {
-			checkName(node.exported, node.exported.name ?? node.exported.value, valueOf(node.local));
+			const value = valueOf(node.right);
+			if (left?.type === 'MemberExpression' && createsCapability(node.right, value))
+				checkName(left.property, propertyName(left.property, left.computed), value);
 		} else if (node.type === 'CallExpression' || node.type === 'OptionalCallExpression') {
 			const callee = valueOf(node.callee);
 			if (callee.kind === 'builtin' && callee.name === 'useMemo') {

package/dist/compiler/native-read-types.js

@@ -57,6 +57,22 @@ export function validateNativeSignalNames(program, file) {
 			if (property) recordSignatures(symbolType(property), nativeReadSignatures);
 		}
 	}
+	function recordFactory(exports, name) {
+		const factory = exports.get(name);
+		const type = factory && symbolType(factory);
+		if (!type) return;
+		for (const signature of checker.getSignaturesOfType(type, ts.SignatureKind.Call)) {
+			const returned = checker.getReturnTypeOfSignature(signature);
+			recordReads(returned, ['get', 'latest', 'snapshot']);
+			for (const property of checker.getPropertiesOfType(returned)) {
+				for (const declaration of property.declarations ?? []) {
+					if (!declaration.name || !ts.isComputedPropertyName(declaration.name)) continue;
+					const marker = canonical(checker.getSymbolAtLocation(declaration.name.expression));
+					if (marker?.name === 'SIGNAL_HANDLE') brands.add(marker);
+				}
+			}
+		}
+	}
 	function inspectModule(symbol, request) {
 		symbol = canonical(symbol);
 		if (!symbol || inspectedModules.has(symbol)) return;
@@ -77,24 +93,14 @@ export function validateNativeSignalNames(program, file) {
 			if (type)
 				for (const signature of checker.getSignaturesOfType(type, ts.SignatureKind.Call))
 					recordReads(checker.getReturnTypeOfSignature(signature), ['get']);
+			for (const name of ['signal$', 'derived$', 'query$']) recordFactory(exports, name);
 		} else if (NATIVE_MODULES.has(request)) {
 			// A project may import only the optional local hook entry. Follow the
 			// trusted export's actual return type to the same nominal declaration;
 			// do not require a redundant bare-engine import or brand lookalikes.
-			const hook = exports.get('useSignal$');
-			const type = hook && symbolType(hook);
-			if (type)
-				for (const signature of checker.getSignaturesOfType(type, ts.SignatureKind.Call)) {
-					const returned = checker.getReturnTypeOfSignature(signature);
-					recordReads(returned, ['get', 'latest', 'snapshot']);
-					for (const property of checker.getPropertiesOfType(returned)) {
-						for (const declaration of property.declarations ?? []) {
-							if (!declaration.name || !ts.isComputedPropertyName(declaration.name)) continue;
-							const marker = canonical(checker.getSymbolAtLocation(declaration.name.expression));
-							if (marker?.name === 'SIGNAL_HANDLE') brands.add(marker);
-						}
-					}
-				}
+			for (const name of ['useSignal$', 'signal$', 'derived$', 'query$']) {
+				recordFactory(exports, name);
+			}
 		} else if (request === 'octane') {
 			const memo = exports.get('useMemo');
 			if (memo) recordSignatures(symbolType(memo), memoSignatures);
@@ -265,26 +271,64 @@ export function validateNativeSignalNames(program, file) {
 				`Native signal handles and functions exposing handles or live reads must end in $. Rename ${JSON.stringify(text)} to ${JSON.stringify(text + '$')}; sampled values keep ordinary names.`,
 			);
 	}
-	function valueExport(node) {
-		if (node.isTypeOnly || node.parent.parent.isTypeOnly) return false;
-		const symbol = canonical(checker.getSymbolAtLocation(node.name));
-		return symbol && (symbol.flags & ts.SymbolFlags.Value) !== 0;
+	function unwrapExpression(node) {
+		while (
+			node &&
+			(ts.isParenthesizedExpression(node) ||
+				ts.isAsExpression(node) ||
+				ts.isTypeAssertionExpression(node) ||
+				ts.isNonNullExpression(node) ||
+				ts.isSatisfiesExpression(node))
+		) {
+			node = node.expression;
+		}
+		return node;
+	}
+	function createsCapability(node) {
+		node = unwrapExpression(node);
+		if (!node) return false;
+		if (ts.isCallExpression(node)) return exposesHandle(checker.getTypeAtLocation(node));
+		return (
+			(ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
+			(exposesHandle(checker.getTypeAtLocation(node)) || exposesLiveRead(node))
+		);
+	}
+	function isDomStyleProperty(node) {
+		let object = node.parent;
+		if (!ts.isObjectLiteralExpression(object)) return false;
+		while (
+			object.parent &&
+			(ts.isParenthesizedExpression(object.parent) ||
+				ts.isAsExpression(object.parent) ||
+				ts.isSatisfiesExpression(object.parent) ||
+				ts.isNonNullExpression(object.parent) ||
+				(ts.isBinaryExpression(object.parent) &&
+					(object.parent.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+						object.parent.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
+						(object.parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken &&
+							object.parent.right === object))) ||
+				(ts.isConditionalExpression(object.parent) &&
+					(object.parent.whenTrue === object || object.parent.whenFalse === object)))
+		)
+			object = object.parent;
+		const container = object.parent;
+		if (!container || !ts.isJsxExpression(container)) return false;
+		const attribute = container.parent;
+		if (!ts.isJsxAttribute(attribute) || attribute.name.getText(sourceFile) !== 'style')
+			return false;
+		const tag = attribute.parent.parent.tagName;
+		return ts.isIdentifier(tag) && /^[a-z]/.test(tag.text);
 	}
 	function visit(node) {
-		if (ts.isVariableDeclaration(node) || ts.isParameter(node) || ts.isBindingElement(node)) {
-			checkName(node.name);
-		} else if (ts.isImportSpecifier(node)) {
-			if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) checkName(node.name);
-		} else if (ts.isExportSpecifier(node)) {
-			if (valueExport(node)) checkName(node.name, node.propertyName ?? node.name);
+		if (ts.isVariableDeclaration(node)) {
+			if (node.initializer && createsCapability(node.initializer))
+				checkName(node.name, node.initializer);
 		} else if (ts.isPropertyAssignment(node)) {
-			checkName(node.name, node.initializer);
-		} else if (
-			ts.isShorthandPropertyAssignment(node) ||
-			ts.isPropertyDeclaration(node) ||
-			ts.isPropertySignature(node)
-		) {
-			checkName(node.name);
+			if (!isDomStyleProperty(node) && createsCapability(node.initializer))
+				checkName(node.name, node.initializer);
+		} else if (ts.isPropertyDeclaration(node)) {
+			if (node.initializer && createsCapability(node.initializer))
+				checkName(node.name, node.initializer);
 		} else if (
 			ts.isFunctionDeclaration(node) ||
 			ts.isMethodDeclaration(node) ||
@@ -295,9 +339,11 @@ export function validateNativeSignalNames(program, file) {
 			ts.isBinaryExpression(node) &&
 			node.operatorToken.kind === ts.SyntaxKind.EqualsToken
 		) {
-			if (ts.isPropertyAccessExpression(node.left)) checkName(node.left.name, node.right);
-			else if (ts.isElementAccessExpression(node.left))
-				checkName(node.left.argumentExpression, node.right);
+			if (createsCapability(node.right)) {
+				if (ts.isPropertyAccessExpression(node.left)) checkName(node.left.name, node.right);
+				else if (ts.isElementAccessExpression(node.left))
+					checkName(node.left.argumentExpression, node.right);
+			}
 		} else if (ts.isCallExpression(node)) {
 			const declaration = checker.getResolvedSignature(node)?.declaration;
 			if (

package/dist/compiler/parser.node.js

@@ -1,7 +1,7 @@
 /** @import { ParseOptions } from '@tsrx/core/types' */
 /** @import { Program } from 'estree' */
 
-import { parseModule as parseNativeModule } from 'oxc-tsrx/tsrx-core-compat';
+import { parseModule as parseNativeModule } from '@tsrx/oxc/tsrx-core-compat';
 import { parseModule as parseJavaScriptModule } from './parser.browser.js';
 
 import { isolateOutputOptions, publishOutput } from './parser-output.js';

package/dist/compiler/renderer-boundaries.js

@@ -8,6 +8,46 @@
  */
 import { parseModule } from '@tsrx/core';
 
+/**
+ * Share renderer ownership across diagnostics for one adopted parser tree.
+ * The lazy proof lives only for that analysis and never reparses editor input.
+ */
+export function createRendererRegionResolver(ast, source, filename, options = {}) {
+	const owner = options.renderer?.id ?? (options.dom === false ? null : 'dom');
+	let regions;
+	return function isDOM(node) {
+		let renderer = owner;
+		if (regions === undefined) {
+			regions =
+				options.rendererBoundaries && Object.keys(options.rendererBoundaries).length > 0
+					? analyzeRendererBoundaries(source, {
+							ast,
+							filename,
+							rendererBoundaries: options.rendererBoundaries,
+						}).boundaries
+					: [];
+		}
+		let narrowest = Infinity;
+		for (const boundary of regions) {
+			const range = boundary.region?.range ?? boundary.region?.valueRange;
+			if (
+				!range ||
+				node.start < range[0] ||
+				node.end > range[1] ||
+				range[1] - range[0] >= narrowest
+			)
+				continue;
+			renderer = boundary.childRenderer;
+			narrowest = range[1] - range[0];
+		}
+		return (
+			renderer === 'dom' ||
+			options.rendererRegistry?.[renderer]?.target === 'dom' ||
+			(renderer === options.renderer?.id && options.renderer?.target === 'dom')
+		);
+	};
+}
+
 const TRANSPARENT_TS_EXPRESSIONS = new Set([
 	'ParenthesizedExpression',
 	'TSAsExpression',