octane 0.2.6 → 0.2.7

package/dist/compiler/index.d.ts

@@ -57,8 +57,6 @@ export interface CompileOptions {
 	dev?: boolean;
 	/** Assert pure immutable-snapshot renders, enable bounded checks, and trust production call memoization. */
 	strong?: boolean;
-	/** Experimental native signal reads in DOM client/server render scopes. */
-	nativeReads?: boolean;
 	profile?: boolean;
 	profileFilename?: string;
 	/** Include out-of-band source-origin inspection data. */
@@ -219,7 +217,7 @@ export function compile(source: string, filename: string, options?: CompileOptio
 export function compileToVolarMappings(
 	source: string,
 	filename?: string,
-	options?: { loose?: boolean; renderers?: unknown; strong?: boolean; nativeReads?: boolean },
+	options?: { loose?: boolean; renderers?: unknown; strong?: boolean },
 ): VolarCompileResult;
 
 /** @internal Shared authored-JSX diagnostic analysis for compiler integrations. */

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

@@ -1,4 +1,4 @@
-import { createLexicalAnalysis } from './compile-universal.js';
+import { createLexicalAnalysis, forEachRuntimeAstChild } from './compile-universal.js';
 import { analyzeRendererBoundaries } from './renderer-boundaries.js';
 import { NATIVE_SIGNAL_NAME, NATIVE_MEMO_READ, nativeReadDiagnostic } from './native-read-facts.js';
 export { NATIVE_SIGNAL_NAME, NATIVE_MEMO_READ } from './native-read-facts.js';
@@ -64,16 +64,51 @@ function propertyName(node, computed = false) {
 		: null;
 }
 
-export function assertNativeReadOptions(options) {
-	if (options?.nativeReads !== undefined && typeof options.nativeReads !== 'boolean') {
-		throw new TypeError('Octane nativeReads must be a boolean.');
+/**
+ * Signal capabilities are part of authored source, not build configuration.
+ * A `$` capability can arrive through props, a namespace, or an imported helper;
+ * do not require a direct signals import or proof of the eventual read target.
+ * Once selected, the entire module captures actual reads, including opaque calls.
+ * Inspect runtime syntax rather than text so erased types, comments, and string
+ * contents do not opt an ordinary module into native memoization and its adapter.
+ */
+export function nativeReadOptions(ast, options) {
+	let nativeReads = false;
+	function visit(node) {
+		if (nativeReads || !node || typeof node !== 'object') return;
+		if (node.importKind === 'type' || node.exportKind === 'type') return;
+		if (
+			node.type === 'ImportDeclaration' &&
+			node.specifiers.length > 0 &&
+			node.specifiers.every((specifier) => specifier.importKind === 'type')
+		) {
+			return;
+		}
+		if (
+			((node.type === 'Identifier' || node.type === 'JSXIdentifier') && node.name.endsWith('$')) ||
+			(node.type === 'ImportDeclaration' &&
+				(node.source?.value === SIGNALS_MODULE || LOCAL_MODULES.has(node.source?.value))) ||
+			((node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') &&
+				String(propertyName(node.property, node.computed) ?? '').endsWith('$')) ||
+			(node.type === 'Property' &&
+				String(propertyName(node.key, node.computed) ?? '').endsWith('$'))
+		) {
+			nativeReads = true;
+			return;
+		}
+		forEachRuntimeAstChild(node, visit);
 	}
+	visit(ast);
+	return { ...options, nativeReads };
+}
+
+export function assertNativeReadOptions(options) {
 	if (
 		options?.nativeReads === true &&
 		options.renderer?.target != null &&
 		options.renderer.target !== 'dom'
 	) {
-		throw new Error('Octane nativeReads currently supports only the DOM client and server.');
+		throw new Error('Octane native signal reads support only the DOM client and server.');
 	}
 }
 
@@ -85,34 +120,7 @@ export function assertNativeReadOptions(options) {
  */
 export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}) {
 	assertNativeReadOptions(options);
-	if (options.nativeReads !== true) {
-		for (const statement of ast.body ?? []) {
-			if (
-				statement.type !== 'ImportDeclaration' ||
-				statement.importKind === 'type' ||
-				!LOCAL_MODULES.has(statement.source?.value)
-			)
-				continue;
-			const capability = (statement.specifiers ?? []).find(
-				(specifier) =>
-					specifier.importKind !== 'type' &&
-					(specifier.type === 'ImportNamespaceSpecifier' ||
-						LOCAL_HOOKS.has(specifier.imported?.name ?? specifier.imported?.value)),
-			);
-			if (capability)
-				return [
-					nativeReadDiagnostic(
-						'OCTANE_NATIVE_READ_OPT_IN',
-						source,
-						filename,
-						capability.start ?? statement.start,
-						capability.end ?? statement.end,
-						'Local native signal hooks require nativeReads: true in the Octane compiler configuration.',
-					),
-				];
-		}
-		return [];
-	}
+	if (!options.nativeReads) return [];
 	if (options.rendererBoundaries && Object.keys(options.rendererBoundaries).length > 0) {
 		const { boundaries } = analyzeRendererBoundaries(source, {
 			ast,
@@ -132,7 +140,7 @@ export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}
 					filename,
 					unsupported.tagRange[0],
 					unsupported.tagRange[1],
-					`Octane nativeReads currently supports only the DOM client and server; renderer ${JSON.stringify(unsupported.childRenderer)} has no native-read integration.`,
+					`Octane native signal reads support only the DOM client and server; renderer ${JSON.stringify(unsupported.childRenderer)} has no native-read integration.`,
 				),
 			];
 	}
@@ -536,7 +544,7 @@ export function analyzeNativeReadDiagnostics(ast, source, filename, options = {}
 			report(
 				'OCTANE_NATIVE_SIGNAL_HOOK',
 				node,
-				'useDerived$ is not available in this experimental integration. Create derived$ on an explicitly owned Scope and pass the handle to the component.',
+				'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));

package/dist/compiler/slot-hooks.d.ts

@@ -4,7 +4,6 @@ import type { CompilerProgram, CompileSourceMap } from './index.js';
 export interface SlotHooksOptions {
 	environment?: 'client' | 'server';
 	strong?: boolean;
-	nativeReads?: boolean;
 	hmr?: boolean;
 	dev?: boolean;
 	profile?: boolean;

package/dist/compiler/slot-hooks.js

@@ -20,7 +20,7 @@ import { NATIVE_SIGNAL_HOOK_NAMES } from './hook-names.js';
 import { METHOD_DEP_IMPORT, annotateHookCalls } from './hook-deps.js';
 import { inlinePlainHookMemos } from './plain-hook-memo.js';
 import { assertStrongMode } from './strong-mode.js';
-import { assertNativeReadDiagnostics, assertNativeReadOptions } from './native-read-diagnostics.js';
+import { assertNativeReadDiagnostics, nativeReadOptions } from './native-read-diagnostics.js';
 import { nativeReadActivationIndex } from './native-read-codegen.js';
 import { findManualHookProviders, manualHookWrapperParameters } from './manual-hooks.js';
 import { findLeadingJsxImportSourcePragma } from './pragma.js';
@@ -1284,7 +1284,7 @@ function parseHookSource(source, id) {
  *
  * @param {string} source raw module text
  * @param {string} id     module id (embedded in the stable Symbol.for key)
- * @param {{ environment?: 'client' | 'server', strong?: boolean, nativeReads?: boolean, hmr?: boolean, dev?: boolean, profile?: boolean, profileFilename?: string, inlineHookMemo?: boolean, manualSlots?: boolean, universalRuntime?: unknown, renderer?: { target?: string }, isVoidComponentImport?: (request: string, imported: string) => boolean }} [options] `hmr: true` (dev serve) emits
+ * @param {{ environment?: 'client' | 'server', strong?: boolean, hmr?: boolean, dev?: boolean, profile?: boolean, profileFilename?: string, inlineHookMemo?: boolean, manualSlots?: boolean, universalRuntime?: unknown, renderer?: { target?: string }, isVoidComponentImport?: (request: string, imported: string) => boolean }} [options] `hmr: true` (dev serve) emits
  *   `Symbol.for(stableKey)` so a re-imported module resolves the same hook
  *   slots (state survives HMR); off (ordinary prod builds and SSR) emits
  *   runtime-ranged Symbols. Profiling retains short described Symbols because
@@ -1295,7 +1295,6 @@ function parseHookSource(source, id) {
  * @returns {{ code: string, map: any } | null}
  */
 export function slotHooks(source, id, options) {
-	assertNativeReadOptions(options);
 	const environment = options?.environment ?? 'client';
 	if (environment !== 'client' && environment !== 'server') {
 		throw new Error(
@@ -1309,6 +1308,7 @@ export function slotHooks(source, id, options) {
 	} catch {
 		return null; // let the normal pipeline surface the parse error
 	}
+	options = nativeReadOptions(ast, options);
 	assertStrongMode(ast, source, id, options);
 	assertNativeReadDiagnostics(ast, source, id, options);
 	const importInfo = octaneHookLocals(

package/dist/compiler/text-type-facts.js

@@ -35,7 +35,7 @@ export function textTypeSourceVersion(source) {
  * because independently falling back on the client/server could change the
  * hydration protocol. Nested ranges are valid when a child expression contains
  * JSX with child expressions of its own.
- * @returns {Set<string> | null}
+ * @returns {{ stringRanges: Set<string>, primitiveRanges: Set<string> } | null}
  */
 export function createTextTypeFactsLookup(facts, filename, source) {
 	if (facts === undefined) return null;
@@ -61,29 +61,43 @@ export function createTextTypeFactsLookup(facts, filename, source) {
 	if (typeof facts.projectVersion !== 'string' || facts.projectVersion.length === 0) {
 		invalid('projectVersion must identify the TypeScript project snapshot');
 	}
-	if (!Array.isArray(facts.stringChildRanges)) invalid('stringChildRanges must be an array');
-	const ranges = new Set();
-	let previousStart = -1;
-	let previousEnd = -1;
-	for (const range of facts.stringChildRanges) {
-		if (
-			!Array.isArray(range) ||
-			range.length !== 2 ||
-			!Number.isSafeInteger(range[0]) ||
-			!Number.isSafeInteger(range[1]) ||
-			range[0] < 0 ||
-			range[0] >= range[1] ||
-			range[1] > source.length
-		) {
-			invalid('stringChildRanges contains an invalid authored range');
+	const validateRanges = (value, name) => {
+		if (!Array.isArray(value)) invalid(`${name} must be an array`);
+		const ranges = new Set();
+		let previousStart = -1;
+		let previousEnd = -1;
+		for (const range of value) {
+			if (
+				!Array.isArray(range) ||
+				range.length !== 2 ||
+				!Number.isSafeInteger(range[0]) ||
+				!Number.isSafeInteger(range[1]) ||
+				range[0] < 0 ||
+				range[0] >= range[1] ||
+				range[1] > source.length
+			) {
+				invalid(`${name} contains an invalid authored range`);
+			}
+			const [start, end] = range;
+			if (start < previousStart || (start === previousStart && end <= previousEnd)) {
+				invalid(`${name} must be sorted and unique`);
+			}
+			previousStart = start;
+			previousEnd = end;
+			ranges.add(`${start}:${end}`);
 		}
-		const [start, end] = range;
-		if (start < previousStart || (start === previousStart && end <= previousEnd)) {
-			invalid('stringChildRanges must be sorted and unique');
-		}
-		previousStart = start;
-		previousEnd = end;
-		ranges.add(`${start}:${end}`);
+		return ranges;
+	};
+	const stringRanges = validateRanges(facts.stringChildRanges, 'stringChildRanges');
+	// The optional field lets older project adapters keep supplying version-1
+	// string-only snapshots. A numeric proof must never masquerade as string
+	// evidence in the compiler's concatenation and local-binding analysis.
+	const primitiveRanges = validateRanges(
+		facts.primitiveTextChildRanges === undefined ? [] : facts.primitiveTextChildRanges,
+		'primitiveTextChildRanges',
+	);
+	for (const range of primitiveRanges) {
+		if (stringRanges.has(range)) invalid('a child has conflicting text proofs');
 	}
-	return ranges;
+	return { stringRanges, primitiveRanges };
 }

package/dist/compiler/typescript.d.ts

@@ -1,4 +1,4 @@
-/** A source-bound, serializable primitive-string proof for JSX child holes. */
+/** Source-bound, serializable primitive-text proofs for JSX child holes. */
 export interface TextTypeFacts {
 	readonly version: 1;
 	/** Clean absolute filename, with forward-slash separators. */
@@ -9,11 +9,18 @@ export interface TextTypeFacts {
 	readonly projectVersion: string;
 	/** Sorted, unique, half-open UTF-16 ranges of authored child expressions. */
 	readonly stringChildRanges: readonly (readonly [start: number, end: number])[];
+	/**
+	 * Number, bigint, and mixed string/number/bigint children. Older version-1
+	 * snapshots omit this field and retain their string-only behavior.
+	 */
+	readonly primitiveTextChildRanges?: readonly (readonly [start: number, end: number])[];
 }
 
 export interface TextTypeProjectOptions {
 	/** Path to the consumer tsconfig. Relative paths resolve from the process cwd. */
 	tsconfig: string;
+	/** Root for project-relative renderer module IDs; defaults to the tsconfig directory. */
+	root?: string;
 	/** The same renderer configuration used by the Octane compiler. */
 	renderers?: unknown;
 }

package/dist/compiler/typescript.js

@@ -188,15 +188,18 @@ function mappedChild(child, sourceMap, generatedChildren, generatedLength) {
 
 /**
  * TypeScript assignability alone is insufficient: `any` and `never` are both
- * assignable to string. Only a primitive-string domain is useful here. Branded
- * string intersections and bounded generic constraints retain that domain;
- * mixed unions, boxed String, and unresolved/error types do not.
+ * assignable to string. A direct child can use the text binding when every
+ * possible value is a primitive string, number, or bigint. Keep a distinct
+ * string result for the compiler's string-only proofs; a mixed union is text,
+ * but it is not evidence for string concatenation. Branded intersections and
+ * bounded generic constraints retain their primitive domain. Boxed values,
+ * nullish/boolean unions, and unresolved/error types do not.
  *
  * This is a typed-program contract, not runtime validation of inaccurate
  * declarations or values smuggled through `any`.
  */
-function isPrimitiveString(type, checker, seen = new Set()) {
-	if (!type || seen.has(type)) return false;
+function primitiveTextKind(type, checker, seen = new Set()) {
+	if (!type || seen.has(type)) return 0;
 	const flags = type.flags;
 	if (
 		flags &
@@ -207,20 +210,33 @@ function isPrimitiveString(type, checker, seen = new Set()) {
 			ts.TypeFlags.Undefined |
 			ts.TypeFlags.Null)
 	) {
-		return false;
+		return 0;
 	}
-	if (flags & ts.TypeFlags.StringLike) return true;
-	if (seen.size >= 64) return false;
+	if (flags & ts.TypeFlags.StringLike) return 1;
+	if (flags & (ts.TypeFlags.NumberLike | ts.TypeFlags.BigIntLike)) return 2;
+	if (seen.size >= 64) return 0;
 	seen.add(type);
-	let result = false;
+	let result = 0;
 	if (type.isUnion()) {
-		result =
-			type.types.length > 0 && type.types.every((part) => isPrimitiveString(part, checker, seen));
+		if (type.types.length > 0) {
+			result = 1;
+			for (const part of type.types) {
+				const kind = primitiveTextKind(part, checker, seen);
+				if (kind === 0) {
+					result = 0;
+					break;
+				}
+				if (kind === 2) result = 2;
+			}
+		}
 	} else if (type.isIntersection()) {
-		result = type.types.some((part) => isPrimitiveString(part, checker, seen));
+		for (const part of type.types) {
+			result = primitiveTextKind(part, checker, seen);
+			if (result !== 0) break;
+		}
 	} else {
 		const constraint = checker.getBaseConstraintOfType(type);
-		if (constraint && constraint !== type) result = isPrimitiveString(constraint, checker, seen);
+		if (constraint && constraint !== type) result = primitiveTextKind(constraint, checker, seen);
 	}
 	seen.delete(type);
 	return result;
@@ -232,18 +248,23 @@ function overlapsDiagnostic(diagnostic, start, end) {
 	return diagnostic.start < end && diagnostic.start + diagnostic.length > start;
 }
 
-function freezeFacts(filename, record, projectVersion, ranges) {
+function freezeRanges(ranges) {
 	const unique = new Map();
 	for (const [start, end] of ranges) unique.set(`${start}:${end}`, [start, end]);
 	const sorted = [...unique.values()].sort(
 		(left, right) => left[0] - right[0] || left[1] - right[1],
 	);
+	return Object.freeze(sorted.map((range) => Object.freeze(range)));
+}
+
+function freezeFacts(filename, record, projectVersion, stringRanges, primitiveRanges) {
 	return Object.freeze({
 		version: TEXT_TYPE_FACTS_VERSION,
 		filename,
 		sourceVersion: record.version,
 		projectVersion,
-		stringChildRanges: Object.freeze(sorted.map((range) => Object.freeze(range))),
+		stringChildRanges: freezeRanges(stringRanges),
+		primitiveTextChildRanges: freezeRanges(primitiveRanges),
 	});
 }
 
@@ -257,6 +278,10 @@ export function createTextTypeProject(options) {
 	}
 	const configFilename = absoluteFilename(options.tsconfig, process.cwd());
 	const directory = nodePath.dirname(configFilename);
+	// TypeScript resolves relative files from its tsconfig; renderer rules use
+	// bundler module IDs, which may be relative to a different project root.
+	const rendererRoot =
+		options.root === undefined ? directory : absoluteFilename(options.root, process.cwd());
 	const renderers = normalizeRendererConfig(options.renderers);
 	const caseSensitive = ts.sys.useCaseSensitiveFileNames;
 	const sources = new FileMap(caseSensitive);
@@ -394,7 +419,7 @@ export function createTextTypeProject(options) {
 		if (cached?.version === version) return cached.code;
 		let compilation = null;
 		try {
-			compilation = compileToVolarMappings(source, rendererFilename(file, directory), {
+			compilation = compileToVolarMappings(source, rendererFilename(file, rendererRoot), {
 				renderers,
 			});
 		} catch {
@@ -470,6 +495,7 @@ export function createTextTypeProject(options) {
 				options: program.getCompilerOptions(),
 				references: loadConfig().projectReferences ?? [],
 				renderers: renderers.signature,
+				rendererRoot,
 				roots: roots(),
 				inputs,
 			}),
@@ -536,7 +562,8 @@ export function createTextTypeProject(options) {
 			cached.projectVersion === version
 		)
 			return cached;
-		const ranges = [];
+		const stringRanges = [];
+		const primitiveRanges = [];
 		const compilerOptions = program.getCompilerOptions();
 		const strictNullChecks = compilerOptions.strictNullChecks ?? compilerOptions.strict ?? false;
 		const sourceFile = program.getSourceFile(file);
@@ -562,8 +589,9 @@ export function createTextTypeProject(options) {
 						) {
 							return;
 						}
-						if (isPrimitiveString(checker.getTypeAtLocation(expression), checker))
-							ranges.push([start, end]);
+						const kind = primitiveTextKind(checker.getTypeAtLocation(expression), checker);
+						if (kind === 1) stringRanges.push([start, end]);
+						else if (kind === 2) primitiveRanges.push([start, end]);
 					};
 					if (compilation) {
 						const sourceMap = new SourceMap(compilation.mappings);
@@ -583,7 +611,7 @@ export function createTextTypeProject(options) {
 				}
 			}
 		}
-		const facts = freezeFacts(file, record, version, ranges);
+		const facts = freezeFacts(file, record, version, stringRanges, primitiveRanges);
 		factsCache.set(file, facts);
 		return facts;
 	};

package/dist/compiler/vite.d.ts

@@ -87,8 +87,12 @@ export interface OctaneVitePluginOptions {
 	 * @default false
 	 */
 	strong?: boolean;
-	/** Experimental native signal reads in DOM client/server render scopes. */
-	nativeReads?: boolean;
+	/**
+	 * @experimental Infer primitive child text from a TypeScript project in
+	 * one-shot production builds. Serve and watched builds retain syntax
+	 * inference. A relative tsconfig is resolved from the Vite project root.
+	 */
+	textTypes?: { tsconfig: string };
 	/**
 	 * Path fragments excluded from Octane's plain `.ts`/`.js` hook-slot pass.
 	 * Prefer package manifest `octane.hookSlots.manual` declarations for bindings.

package/dist/compiler/vite.js

@@ -26,6 +26,7 @@ import {
 	findDescriptorChildrenExports,
 	findDescriptorChildrenImports,
 	findVoidComponentImports,
+	resolveRendererForFile,
 } from './bundler.js';
 import {
 	isPlainCssModuleId,
@@ -533,12 +534,21 @@ function assertProfilingDefineAvailable(definitions, enabled) {
 }
 
 export function octane(options = {}) {
-	if (options.nativeReads !== undefined && typeof options.nativeReads !== 'boolean') {
-		throw new TypeError('octane/compiler/vite: nativeReads must be a boolean when provided.');
-	}
 	if (options.strong !== undefined && typeof options.strong !== 'boolean') {
 		throw new TypeError('octane/compiler/vite: `strong` must be a boolean when provided.');
 	}
+	if (
+		options.textTypes !== undefined &&
+		(options.textTypes === null ||
+			typeof options.textTypes !== 'object' ||
+			Array.isArray(options.textTypes) ||
+			Object.keys(options.textTypes).some((key) => key !== 'tsconfig') ||
+			typeof options.textTypes.tsconfig !== 'string' ||
+			options.textTypes.tsconfig.trim() !== options.textTypes.tsconfig ||
+			options.textTypes.tsconfig.length === 0)
+	) {
+		throw new TypeError('octane/compiler/vite: `textTypes` requires { tsconfig: string }.');
+	}
 	if (
 		options.cssModuleConstants !== undefined &&
 		typeof options.cssModuleConstants !== 'function'
@@ -595,6 +605,63 @@ export function octane(options = {}) {
 	// CSS naming/virtual providers can differ between them, so never key a proof
 	// merely by its path or share a previous build's final-module snapshot.
 	const cssModuleProofStates = new Map();
+	let textTypeProject = null;
+	let createTextTypeProject = null;
+	let typedTextEnabled = false;
+	const textTypeFiles = new Map();
+	const releaseTextTypeProject = () => {
+		textTypeProject?.dispose();
+		textTypeProject = null;
+	};
+	const resetTextTypes = () => {
+		releaseTextTypeProject();
+		createTextTypeProject = null;
+		typedTextEnabled = false;
+		textTypeFiles.clear();
+	};
+	const textFactsFor = (source, id, environment) => {
+		if (!typedTextEnabled || createTextTypeProject === null) return undefined;
+		const file = cleanModuleId(id);
+		if (!nodePath.isAbsolute(file) || !/\.(?:tsrx|tsx)$/.test(file) || !nodeFs.existsSync(file)) {
+			return undefined;
+		}
+		// Installed source packages may use another tsconfig and need not be in
+		// this project's TypeScript graph. Their ordinary syntax path stays intact.
+		if (!compiler._isProjectOwnedSource(file)) return undefined;
+		const canonical = compiler._canonicalModuleId(file);
+		const pragmaOwned = file.endsWith('.tsx') && compiler._pragmaClaimsOwnership(source);
+		if (!compiler._passesOwnershipGate(file, canonical, pragmaOwned)) return undefined;
+		const renderer = resolveRendererForFile(compiler.renderers, canonical);
+		if (
+			renderer.target !== 'dom' ||
+			(environment === 'server' && renderer.server === 'client-only')
+		)
+			return undefined;
+		textTypeProject ??= createTextTypeProject({
+			tsconfig: nodePath.resolve(projectRoot, options.textTypes.tsconfig),
+			root: projectRoot,
+			renderers: options.renderers,
+		});
+		const facts = textTypeProject.snapshot(file, source);
+		const previous = textTypeFiles.get(canonical);
+		if (
+			previous !== undefined &&
+			(previous.sourceVersion !== facts.sourceVersion ||
+				previous.projectVersion !== facts.projectVersion)
+		) {
+			throw new Error(
+				`Octane text types changed during the client/server build for ${JSON.stringify(canonical)}. Restart the build to keep hydration consistent.`,
+			);
+		}
+		textTypeFiles.set(canonical, {
+			sourceVersion: facts.sourceVersion,
+			projectVersion: facts.projectVersion,
+		});
+		// Runtime compiler IDs are portable root-relative paths. TypeScript reads
+		// the real file; only its filename is translated after checking that exact
+		// source against the project. Both targets reuse this one proof generation.
+		return { ...facts, filename: canonical };
+	};
 	const cssModuleProofState = (context, environment) => {
 		const key = context.environment ?? environment;
 		let state = cssModuleProofStates.get(key);
@@ -617,7 +684,6 @@ export function octane(options = {}) {
 		exclude: options.exclude,
 		profile: profileEnabled,
 		strong: options.strong,
-		nativeReads: options.nativeReads,
 		renderers: options.renderers,
 		requireDirective,
 		warn,
@@ -626,6 +692,7 @@ export function octane(options = {}) {
 	const forceSsr = options.ssr;
 
 	const resetCompiler = (root) => {
+		resetTextTypes();
 		descriptorSourceCache.clear();
 		descriptorExportCache.clear();
 		descriptorGraphCache.clear();
@@ -637,7 +704,6 @@ export function octane(options = {}) {
 			exclude: options.exclude,
 			profile: profileEnabled,
 			strong: options.strong,
-			nativeReads: options.nativeReads,
 			renderers: options.renderers,
 			requireDirective,
 			warn,
@@ -706,12 +772,20 @@ export function octane(options = {}) {
 			// proof to one-shot production builds where the graph is compiled together.
 			specializeProductionRoots = config.command === 'build' && config.build?.watch == null;
 			specializeCssModuleConstants = specializeProductionRoots && !hmrEnabled;
+			typedTextEnabled =
+				options.textTypes !== undefined && specializeProductionRoots && !hmrEnabled;
+			if (typedTextEnabled) {
+				return import('./typescript.js').then((module) => {
+					createTextTypeProject = module.createTextTypeProject;
+				});
+			}
 		},
 		buildStart() {
 			if (this.environment === undefined) cssModuleProofStates.clear();
 			else cssModuleProofStates.delete(this.environment);
 		},
 		buildEnd(error) {
+			if (error) releaseTextTypeProject();
 			const keys = this.environment === undefined ? ['client', 'server'] : [this.environment];
 			for (const key of keys) {
 				const state = cssModuleProofStates.get(key);
@@ -725,6 +799,8 @@ export function octane(options = {}) {
 		},
 		watchChange(id) {
 			compiler.invalidate(id);
+			// A one-shot build can receive a watch event mid-build and must fail closed.
+			textTypeProject?.invalidate(cleanModuleId(id));
 			// A barrel can cache a classification reached through this source, so
 			// invalidate the small descriptor graph as a unit on authored edits.
 			descriptorSourceCache.clear();
@@ -732,6 +808,9 @@ export function octane(options = {}) {
 			descriptorGraphCache.clear();
 			cssModuleProofStates.clear();
 		},
+		closeBundle() {
+			releaseTextTypeProject();
+		},
 		generateBundle(_outputOptions, bundle) {
 			if (!emitClientReferenceManifest) return;
 			const manifest = clientReferenceManifest(this, bundle);
@@ -819,6 +898,7 @@ export function octane(options = {}) {
 						? null
 						: { _descriptorChildrenExportsProof: preflight.descriptorExportsProof }),
 					environment,
+					...(typedTextEnabled ? { textTypeFacts: textFactsFor(code, id, environment) } : null),
 					hmr: !server && hmrEnabled ? 'vite' : false,
 					// DEV server transforms also carry SSR-only diagnostics. HMR itself
 					// remains client-only; an explicit `hmr: false` keeps both transforms

package/dist/compiler/volar.d.ts

@@ -3,7 +3,7 @@
 export function compileToVolarMappings(
 	source: string,
 	filename?: string,
-	options?: { loose?: boolean; renderers?: unknown; strong?: boolean; nativeReads?: boolean },
+	options?: { loose?: boolean; renderers?: unknown; strong?: boolean },
 ): import('./index.js').VolarCompileResult;
 
 /** Virtual TSX and authored ranges used by compiler inspection tooling. */

package/dist/compiler/volar.js

@@ -32643,7 +32643,7 @@ function parseModule(source, filename, options) {
 import { buildFatSegments, decodeSourceMappings } from "./fat-segments.js";
 import { analyzeNativeChangeDiagnostics } from "./native-change-diagnostics.js";
 import { analyzeStrongMode } from "./strong-mode.js";
-import { analyzeNativeReadDiagnostics } from "./native-read-diagnostics.js";
+import { analyzeNativeReadDiagnostics, nativeReadOptions } from "./native-read-diagnostics.js";
 import { jsxImportSourcePragmaModule } from "./pragma.js";
 import {
   DOM_RENDERER_MODULE,
@@ -32765,12 +32765,17 @@ function compileToVolarMappings(source, filename, options) {
   }).diagnostics;
   const strongDiagnostics = options?.strong === true || source.includes("use strong") ? analyzeStrongMode(ast, source, filename, options).diagnostics : null;
   if (strongDiagnostics !== null) diagnostics.push(...strongDiagnostics);
-  const nativeReadDiagnostics = analyzeNativeReadDiagnostics(ast, source, filename, {
-    ...options,
-    renderer,
-    rendererBoundaries: rendererConfig.boundaries,
-    rendererRegistry: rendererConfig.registry
-  });
+  const nativeReadDiagnostics = analyzeNativeReadDiagnostics(
+    ast,
+    source,
+    filename,
+    nativeReadOptions(ast, {
+      ...options,
+      renderer,
+      rendererBoundaries: rendererConfig.boundaries,
+      rendererRegistry: rendererConfig.registry
+    })
+  );
   diagnostics.push(...nativeReadDiagnostics);
   const rendererPragma = hasAuthoredLeadingPragma(ast, comments) ? null : createRendererTypePragma(renderer, ast);
   const printComments = rendererPragma === null ? comments : [rendererPragma, ...comments];