@octanejs/rspack-plugin 0.1.48 → 0.1.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octanejs/rspack-plugin",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -45,7 +45,7 @@
   },
   "peerDependencies": {
     "@rspack/core": "^2.0.0",
-    "octane": "^0.1.51 || ^0.2.0"
+    "octane": "^0.2.13"
   },
   "devDependencies": {
     "@rspack/core": "^2.1.4",
@@ -54,7 +54,7 @@
     "css-loader": "6.11.0",
     "jsdom": "^30.0.1",
     "vitest": "^4.1.10",
-    "octane": "0.2.4"
+    "octane": "0.2.13"
   },
   "scripts": {
     "test": "vitest run --config vitest.config.js"

package/src/loader.js

@@ -1,7 +1,8 @@
-import { realpathSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
 import { dirname, isAbsolute, resolve } from 'node:path';
 import remapping from '@jridgewell/remapping';
 import { canonicalModuleId, cleanModuleId, createOctaneCompiler } from 'octane/compiler/bundler';
+import { resolveRendererForFile } from 'octane/compiler/renderers';
 import {
 	clearCssModuleBuildInfo,
 	CSS_MODULE_CONTEXT_KEY,
@@ -14,6 +15,7 @@ import {
 	selectLayerCompilerOptions,
 } from './shared.js';
 import { loadDescriptorChildrenImports } from './descriptor-children.js';
+import { textTypeFactsForLoader } from './text-types.js';
 
 function realRoot(path) {
 	try {
@@ -119,7 +121,9 @@ export default function octaneLoader(source, inputSourceMap) {
 			root,
 			profile,
 			...(options.strong === undefined ? null : { strong: options.strong }),
-			...(options.nativeReads === undefined ? null : { nativeReads: options.nativeReads }),
+			...(options.knownAttributeSpreads === undefined
+				? null
+				: { knownAttributeSpreads: options.knownAttributeSpreads }),
 			...(options.exclude === undefined ? null : { exclude: options.exclude }),
 			...(compilerOptions.renderers === undefined
 				? null
@@ -135,6 +139,41 @@ export default function octaneLoader(source, inputSourceMap) {
 		});
 		const id = realModuleId(this.resource ?? this.resourcePath);
 		const authoredSource = String(source);
+		const textTypeCandidate =
+			options.textTypes !== undefined && this.mode === 'production' && !dev && this.hot !== true;
+		let textTypeFilename;
+		if (textTypeCandidate) {
+			const file = cleanModuleId(id);
+			if (
+				/(?:\.tsrx|\.tsx)$/i.test(file) &&
+				existsSync(file) &&
+				compiler._isProjectOwnedSource(file)
+			) {
+				const canonical = compiler._canonicalModuleId(file);
+				const pragmaOwned =
+					file.endsWith('.tsx') && compiler._pragmaClaimsOwnership(authoredSource);
+				if (compiler._passesOwnershipGate(file, canonical, pragmaOwned)) {
+					const renderer = resolveRendererForFile(compiler.renderers, canonical);
+					if (
+						renderer.target === 'dom' &&
+						!(environment === 'server' && renderer.server === 'client-only')
+					) {
+						textTypeFilename = canonical;
+					}
+				}
+			}
+		}
+		if (textTypeFilename !== undefined) {
+			// An imported type can change while this module's source stays the same.
+			// Rspack's persistent module cache has no dependency edges to every TS
+			// Program input. Production watches stay syntax-only but must not persist
+			// their generic output for a later one-shot typed build either.
+			this.cacheable?.(false);
+		}
+		const textTypes =
+			textTypeFilename !== undefined &&
+			this._compiler?.watchMode !== true &&
+			this._compiler?.options?.watch !== true;
 		const cssModuleConstants =
 			this[CSS_MODULE_CONTEXT_KEY]?.enabled === true
 				? prepareCssModuleConstants(this, compiler, authoredSource, id, {
@@ -143,7 +182,7 @@ export default function octaneLoader(source, inputSourceMap) {
 						dev,
 					})
 				: null;
-		const finish = (clientOnlyImports, isDescriptorChildrenImport, callback) => {
+		const finish = (clientOnlyImports, isDescriptorChildrenImport, textTypeFacts, callback) => {
 			try {
 				const result = compiler.transform(authoredSource, id, {
 					environment,
@@ -152,6 +191,7 @@ export default function octaneLoader(source, inputSourceMap) {
 					profile,
 					...(clientOnlyImports.length > 0 ? { clientOnlyImports } : null),
 					...(isDescriptorChildrenImport === null ? null : { isDescriptorChildrenImport }),
+					...(textTypeFacts === undefined ? null : { textTypeFacts }),
 					...cssModuleConstants?.transformOptions,
 				});
 
@@ -168,11 +208,16 @@ export default function octaneLoader(source, inputSourceMap) {
 				}
 				setBuildInfo(this._module, {
 					canonicalId: canonicalModuleId(id, root),
+					resourceQuery: id.slice(cleanModuleId(id).length),
 					transformKind: result.kind,
+					...(result.streamedSignals === true ? { streamedSignals: true } : null),
 					serverRpc:
 						result.kind === 'compile' &&
 						(result.code.includes('_$__serverRpc(') ||
 							result.code.includes('export const _$_server_$_')),
+					...(Array.isArray(result.independentWidgets) && result.independentWidgets.length > 0
+						? { independentWidgets: result.independentWidgets }
+						: null),
 					...(result.universalRuntime === undefined
 						? null
 						: { universalRuntime: result.universalRuntime }),
@@ -206,18 +251,33 @@ export default function octaneLoader(source, inputSourceMap) {
 			/\.(?:tsrx|tsx)$/.test(cleanModuleId(id)) &&
 			/<\s*[A-Z_$]/.test(authoredSource) &&
 			authoredSource.includes('import');
-		if (requests.length > 0 || mayUseDescriptorImports) {
+		if (requests.length > 0 || mayUseDescriptorImports || textTypes) {
 			const asyncCallback = this.async?.() ?? callback;
 			Promise.all([
 				requests.length > 0 ? resolveClientOnlyImports(this, compiler, authoredSource, id) : [],
 				mayUseDescriptorImports ? loadDescriptorChildrenImports(this, authoredSource, id) : null,
+				textTypes
+					? textTypeFactsForLoader(
+							this._compiler,
+							options.textTypes.tsconfig,
+							compilerOptions.renderers,
+							cleanModuleId(id),
+							authoredSource,
+						).then((facts) => ({
+							...facts,
+							// The neutral compiler uses a project-relative module identity;
+							// the checker necessarily reads the real filesystem filename.
+							filename: textTypeFilename,
+						}))
+					: undefined,
 			]).then(
-				([imports, descriptorImport]) => finish(imports, descriptorImport, asyncCallback),
+				([imports, descriptorImport, textTypeFacts]) =>
+					finish(imports, descriptorImport, textTypeFacts, asyncCallback),
 				(error) => asyncCallback(error instanceof Error ? error : new Error(String(error))),
 			);
 			return;
 		}
-		finish([], null, callback);
+		finish([], null, undefined, callback);
 	} catch (error) {
 		this.callback(error instanceof Error ? error : new Error(String(error)));
 	}

package/src/plugin.js

@@ -5,15 +5,22 @@ import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
 	CLIENT_REFERENCE_MANIFEST_FILENAME,
+	INDEPENDENT_HYDRATION_MANIFEST_FILENAME,
 	createClientReferenceManifest,
 	createOctaneCompiler,
 } from 'octane/compiler/bundler';
 import { installCssModuleConstants } from './css-module-constants.js';
+import { createStreamedSignalHmrRuntimeModule } from './streamed-signals-hmr.js';
 import {
 	getOctaneRspackBuildInfo,
 	inferRspackEnvironment,
 	normalizePluginOptions,
 } from './shared.js';
+import {
+	disposeTextTypeCompiler,
+	invalidateTextTypeCompiler,
+	registerTextTypeCompiler,
+} from './text-types.js';
 
 const PLUGIN_NAME = 'OctaneRspackPlugin';
 const PROFILE_DEFINE = '__OCTANE_PROFILE_ENABLED__';
@@ -177,7 +184,9 @@ function createDiscoveryCompiler(options, root, profile, specialization) {
 		root,
 		profile,
 		...(options.strong === undefined ? null : { strong: options.strong }),
-		...(options.nativeReads === undefined ? null : { nativeReads: options.nativeReads }),
+		...(options.knownAttributeSpreads === undefined
+			? null
+			: { knownAttributeSpreads: options.knownAttributeSpreads }),
 		...(options.exclude === undefined ? null : { exclude: options.exclude }),
 		...(renderers === undefined ? null : { renderers }),
 		...(universalRuntime === undefined ? null : { universalRuntime }),
@@ -230,16 +239,17 @@ function visitClientReferenceModules(
 	inheritedChunks,
 	visit,
 	seen = new Set(),
+	executableModule = module,
 ) {
 	if (!module || seen.has(module)) return;
 	seen.add(module);
 	const chunks = moduleChunks(compilation, module, inheritedChunks);
-	visit(module, chunks);
+	visit(module, chunks, executableModule);
 	for (const child of iterable(module.modules)) {
-		visitClientReferenceModules(compilation, child, chunks, visit, seen);
+		visitClientReferenceModules(compilation, child, chunks, visit, seen, module);
 	}
 	if (module.rootModule) {
-		visitClientReferenceModules(compilation, module.rootModule, chunks, visit, seen);
+		visitClientReferenceModules(compilation, module.rootModule, chunks, visit, seen, module);
 	}
 }
 
@@ -275,6 +285,158 @@ function emitClientReferenceManifest(compiler, compilation) {
 	);
 }
 
+function emitIndependentHydrationManifest(compiler, compilation, mode) {
+	const modules = collectIndependentHydrationModules(compilation);
+	const widgets = {};
+	for (const { template, target } of independentHydrationTargets(modules)) {
+		const activationChunks = new Set(target.chunks);
+		for (const chunk of target.chunks) {
+			for (const referenced of iterable(chunk?.getAllReferencedChunks?.())) {
+				activationChunks.add(referenced);
+			}
+		}
+		const files = [...activationChunks]
+			.flatMap((chunk) => [...iterable(chunk.files), ...iterable(chunk.auxiliaryFiles)])
+			.map(String);
+		widgets[template.boundaryId] = {
+			version: 1,
+			boundaryId: template.boundaryId,
+			// Rspack chunks are runtime payloads, not native module namespaces. The
+			// initial runtime module below owns the actual chunk-load + require closure.
+			moduleId: template.boundaryId,
+			exportName: template.exportName,
+			captureSchema: template.captureSchema,
+			hookSeed: template.hookSeed,
+			idSeed: template.idSeed,
+			signalSites: template.signalSites,
+			styles: [...new Set(files.filter((file) => /\.css(?:\?|$)/.test(file)))].sort(),
+			parentDependencies: false,
+		};
+	}
+	const records = Object.fromEntries(
+		Object.entries(widgets).sort(([left], [right]) => left.localeCompare(right)),
+	);
+	// Match the native __webpack_hash__ value captured by the executing entry.
+	// A widget-schema hash does not fence changes elsewhere in its client graph.
+	const buildId = compilation.hash;
+	if (typeof buildId !== 'string' || !buildId) {
+		throw new Error('Octane client build has no completed compilation hash.');
+	}
+	const independentHydration = Object.keys(records).length !== 0;
+	compilation.emitAsset(
+		'octane-client-build.json',
+		new compiler.webpack.sources.RawSource(
+			JSON.stringify(
+				{ version: 1, buildId, mode, capabilities: { independentHydration } },
+				null,
+				2,
+			) + '\n',
+		),
+	);
+	if (!independentHydration) return;
+	compilation.emitAsset(
+		INDEPENDENT_HYDRATION_MANIFEST_FILENAME,
+		new compiler.webpack.sources.RawSource(
+			JSON.stringify({ version: 1, buildId, widgets: records }, null, 2) + '\n',
+		),
+	);
+}
+
+function collectIndependentHydrationModules(compilation) {
+	const modules = [];
+	for (const topLevelModule of iterable(compilation.modules)) {
+		visitClientReferenceModules(
+			compilation,
+			topLevelModule,
+			[],
+			(module, chunks, executableModule) => {
+				const info = getOctaneRspackBuildInfo(module);
+				if (info !== null) modules.push({ module, executableModule, info, chunks });
+			},
+			new Set(),
+		);
+	}
+	return modules;
+}
+
+function independentHydrationTargets(modules) {
+	const targets = [];
+	for (const { info } of modules) {
+		for (const template of info.independentWidgets ?? []) {
+			const query = template.request.slice(template.request.indexOf('?'));
+			const candidates = modules.filter(
+				(candidate) =>
+					candidate.info.canonicalId === template.moduleId &&
+					candidate.info.resourceQuery?.includes(query),
+			);
+			const target =
+				candidates.find(
+					(candidate) =>
+						candidate.executableModule != null && candidate.executableModule !== candidate.module,
+				) ?? candidates[0];
+			if (target === undefined) {
+				throw new Error(
+					`Octane independent Hydrate ${JSON.stringify(template.boundaryId)} has no emitted activation chunk.`,
+				);
+			}
+			targets.push({ template, target });
+		}
+	}
+	return targets;
+}
+
+function independentHydrationRuntimeModule(compiler, compilation) {
+	const { RuntimeGlobals, RuntimeModule } = compiler.webpack;
+	return class OctaneIndependentHydrationRuntimeModule extends RuntimeModule {
+		constructor() {
+			super('octane independent hydration loaders');
+			this.fullHash = true;
+		}
+
+		generate() {
+			const registrations = [];
+			const seen = new Set();
+			for (const { template, target } of independentHydrationTargets(
+				collectIndependentHydrationModules(compilation),
+			)) {
+				if (seen.has(template.boundaryId)) continue;
+				seen.add(template.boundaryId);
+				const candidates = [target.executableModule, target.module, target.module?.rootModule];
+				const executable = candidates.find(
+					(module) => module != null && compilation.chunkGraph.getModuleId(module) != null,
+				);
+				if (executable === undefined) {
+					throw new Error(
+						`Octane independent Hydrate ${JSON.stringify(template.boundaryId)} has no executable Rspack module.`,
+					);
+				}
+				const moduleId = compilation.chunkGraph.getModuleId(executable);
+				const activationChunks = new Set(target.chunks);
+				for (const chunk of target.chunks) {
+					for (const referenced of iterable(chunk?.getAllReferencedChunks?.())) {
+						activationChunks.add(referenced);
+					}
+				}
+				const chunkIds = [...activationChunks]
+					.filter((chunk) => chunk !== this.chunk && chunk?.id != null)
+					.map((chunk) => chunk.id)
+					.sort((left, right) => String(left).localeCompare(String(right)));
+				const load =
+					chunkIds.length === 0
+						? 'Promise.resolve()'
+						: `Promise.all(${JSON.stringify(chunkIds)}.map(${RuntimeGlobals.ensureChunk}))`;
+				registrations.push(
+					`${RuntimeGlobals.global}.__OCTANE_INDEPENDENT_MODULES__[${JSON.stringify(template.boundaryId)}] = function() { return ${load}.then(function() { return ${RuntimeGlobals.require}(${JSON.stringify(moduleId)}); }); };`,
+				);
+			}
+			return [
+				`${RuntimeGlobals.global}.__OCTANE_INDEPENDENT_MODULES__ ||= Object.create(null);`,
+				...registrations,
+			].join('\n');
+		}
+	};
+}
+
 function defineMatchesBoolean(value, expected) {
 	return value === expected || value === JSON.stringify(expected);
 }
@@ -360,6 +522,16 @@ export class OctaneRspackPlugin {
 			compiler.options.mode === 'production' &&
 			!dev &&
 			!hotModuleReplacement;
+		// Loader worker pools cannot share one TypeScript Program. Watch and HMR
+		// use syntax-only compilation, including production-mode watch builds.
+		const textTypes =
+			this.options.textTypes !== undefined &&
+			compiler.options.mode === 'production' &&
+			!dev &&
+			!hotModuleReplacement;
+		const tsconfig = textTypes
+			? realRoot(resolve(root, this.options.textTypes.tsconfig))
+			: undefined;
 		assertProfilingDefineAvailable(compiler, profile);
 		saltPersistentCacheVersion(compiler, {
 			root,
@@ -368,7 +540,7 @@ export class OctaneRspackPlugin {
 			dev,
 			profile,
 			strong: this.options.strong === true,
-			nativeReads: this.options.nativeReads === true,
+			knownAttributeSpreads: this.options.knownAttributeSpreads,
 			exclude: this.options.exclude ?? [],
 			renderers: this.options.renderers?.signature,
 			runtime: this.options.runtime,
@@ -379,7 +551,14 @@ export class OctaneRspackPlugin {
 			requireDirective: this.options.requireDirective === true,
 			transpile: this.options.transpile !== false,
 			cssModuleConstants,
+			textTypes: tsconfig,
 		});
+		if (tsconfig !== undefined) {
+			registerTextTypeCompiler(compiler, tsconfig, root);
+			compiler.hooks.run?.tap(PLUGIN_NAME, () => invalidateTextTypeCompiler(compiler));
+			compiler.hooks.watchRun?.tap(PLUGIN_NAME, () => invalidateTextTypeCompiler(compiler));
+			compiler.hooks.shutdown?.tap(PLUGIN_NAME, () => disposeTextTypeCompiler(compiler));
+		}
 		installProfilingDefine(compiler, profile);
 		if (cssModuleConstants) {
 			installCssModuleConstants(compiler, {
@@ -409,9 +588,9 @@ export class OctaneRspackPlugin {
 			environment,
 			profile,
 			...(this.options.strong === undefined ? null : { strong: this.options.strong }),
-			...(this.options.nativeReads === undefined
+			...(this.options.knownAttributeSpreads === undefined
 				? null
-				: { nativeReads: this.options.nativeReads }),
+				: { knownAttributeSpreads: this.options.knownAttributeSpreads }),
 			...(this.options.hmr === undefined ? null : { hmr: this.options.hmr }),
 			...(this.options.dev === undefined ? null : { dev: this.options.dev }),
 			...(this.options.exclude === undefined ? null : { exclude: this.options.exclude }),
@@ -425,13 +604,14 @@ export class OctaneRspackPlugin {
 			...(this.options.requireDirective === undefined
 				? null
 				: { requireDirective: this.options.requireDirective }),
+			...(tsconfig === undefined ? null : { textTypes: { tsconfig } }),
 		};
 		compiler.options.module.rules.push({
 			test: OCTANE_RULE,
 			type: 'javascript/auto',
 			enforce: 'pre',
 			use:
-				this.options.parallel === false
+				this.options.parallel === false || textTypes
 					? [{ loader: loaderPath, options: loaderOptions }]
 					: [
 							{ loader: finalizeLoaderPath, options: loaderOptions },
@@ -497,12 +677,56 @@ export class OctaneRspackPlugin {
 			addDependencies(compilation.fileDependencies, current.dependencies);
 			addDependencies(compilation.missingDependencies, current.missingDependencies);
 			if (environment === 'client') {
+				const IndependentHydrationRuntimeModule = independentHydrationRuntimeModule(
+					compiler,
+					compilation,
+				);
+				compilation.hooks.additionalTreeRuntimeRequirements?.tap(
+					PLUGIN_NAME,
+					(chunk, runtimeRequirements) => {
+						if (!chunk.hasRuntime?.()) return;
+						const modules = collectIndependentHydrationModules(compilation);
+						const featureModules = modules.filter(
+							({ info }) =>
+								info.streamedSignals === true || (info.independentWidgets?.length ?? 0) > 0,
+						);
+						if (
+							featureModules.length > 0 &&
+							compiler.options.plugins.some(
+								(plugin) => plugin instanceof compiler.webpack.HotModuleReplacementPlugin,
+							)
+						) {
+							runtimeRequirements.add(compiler.webpack.RuntimeGlobals.interceptModuleExecution);
+							runtimeRequirements.add(compiler.webpack.RuntimeGlobals.moduleCache);
+							runtimeRequirements.add(compiler.webpack.RuntimeGlobals.global);
+							compilation.addRuntimeModule(
+								chunk,
+								createStreamedSignalHmrRuntimeModule(compiler, compilation, featureModules),
+							);
+						}
+						if (independentHydrationTargets(modules).length === 0) {
+							return;
+						}
+						runtimeRequirements.add(compiler.webpack.RuntimeGlobals.ensureChunk);
+						runtimeRequirements.add(compiler.webpack.RuntimeGlobals.global);
+						runtimeRequirements.add(compiler.webpack.RuntimeGlobals.require);
+						compilation.addRuntimeModule(chunk, new IndependentHydrationRuntimeModule());
+					},
+				);
 				compilation.hooks.processAssets.tap(
 					{
 						name: PLUGIN_NAME,
 						stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT,
 					},
-					() => emitClientReferenceManifest(compiler, compilation),
+					() => {
+						emitClientReferenceManifest(compiler, compilation);
+						emitIndependentHydrationManifest(
+							compiler,
+							compilation,
+							this.options.clientBuildMode ??
+								(compiler.options.mode === 'development' ? 'development' : 'production'),
+						);
+					},
 				);
 			}
 		});

package/src/shared.js

@@ -41,12 +41,13 @@ const LOADER_OPTION_KEYS = new Set([
 	'dev',
 	'profile',
 	'strong',
-	'nativeReads',
+	'knownAttributeSpreads',
 	'exclude',
 	'renderers',
 	'requireDirective',
 	'universalRuntime',
 	'layerSpecializations',
+	'textTypes',
 ]);
 const PLUGIN_OPTION_KEYS = new Set([
 	...LOADER_OPTION_KEYS,
@@ -54,6 +55,7 @@ const PLUGIN_OPTION_KEYS = new Set([
 	'runtime',
 	'transpile',
 	'cssModuleConstants',
+	'clientBuildMode',
 ]);
 const LAYER_SPECIALIZATION_KEYS = new Set(['runtime', 'renderers', 'universalRuntime']);
 
@@ -198,6 +200,16 @@ function normalizeOptions(value, plugin) {
 		throw new TypeError('@octanejs/rspack-plugin: `root` must be a path string.');
 	}
 	if (plugin) normalizeRuntimeRequest(options.runtime);
+	if (
+		plugin &&
+		options.clientBuildMode !== undefined &&
+		options.clientBuildMode !== 'production' &&
+		options.clientBuildMode !== 'development'
+	) {
+		throw new TypeError(
+			'@octanejs/rspack-plugin: `clientBuildMode` must be "production" or "development".',
+		);
+	}
 	if (
 		options.environment !== undefined &&
 		options.environment !== 'client' &&
@@ -209,7 +221,6 @@ function normalizeOptions(value, plugin) {
 	assertBooleanOption(options, 'dev');
 	assertBooleanOption(options, 'profile');
 	assertBooleanOption(options, 'strong');
-	assertBooleanOption(options, 'nativeReads');
 	assertBooleanOption(options, 'requireDirective');
 	if (
 		options.exclude !== undefined &&
@@ -218,6 +229,21 @@ function normalizeOptions(value, plugin) {
 		throw new TypeError('@octanejs/rspack-plugin: `exclude` must be an array of path strings.');
 	}
 	if (plugin) assertBooleanOption(options, 'transpile');
+	if (options.textTypes !== undefined) {
+		if (
+			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
+		) {
+			throw new TypeError(
+				'@octanejs/rspack-plugin: `textTypes` must be an object with a non-empty `tsconfig` path.',
+			);
+		}
+	}
 	if (
 		plugin &&
 		options.cssModuleConstants !== undefined &&
@@ -241,7 +267,9 @@ function normalizeOptions(value, plugin) {
 		...(options.dev === undefined ? null : { dev: options.dev }),
 		...(options.profile === undefined ? null : { profile: options.profile }),
 		...(options.strong === undefined ? null : { strong: options.strong }),
-		...(options.nativeReads === undefined ? null : { nativeReads: options.nativeReads }),
+		...(options.knownAttributeSpreads === undefined
+			? null
+			: { knownAttributeSpreads: options.knownAttributeSpreads }),
 		...(options.exclude === undefined ? null : { exclude: [...options.exclude] }),
 		...(renderers === undefined ? null : { renderers }),
 		...(universalRuntime === undefined ? null : { universalRuntime }),
@@ -249,7 +277,13 @@ function normalizeOptions(value, plugin) {
 		...(options.requireDirective === undefined
 			? null
 			: { requireDirective: options.requireDirective }),
+		...(options.textTypes === undefined
+			? null
+			: { textTypes: Object.freeze({ tsconfig: options.textTypes.tsconfig }) }),
 		...(plugin && parallel !== undefined ? { parallel } : null),
+		...(plugin && options.clientBuildMode !== undefined
+			? { clientBuildMode: options.clientBuildMode }
+			: null),
 		...(plugin && options.transpile !== undefined ? { transpile: options.transpile } : null),
 		...(plugin && options.runtime !== undefined ? { runtime: options.runtime } : null),
 		...(plugin && options.cssModuleConstants !== undefined
@@ -291,6 +325,8 @@ export function getOctaneRspackBuildInfo(module) {
 			value.transformKind === 'slots' ||
 			value.transformKind === 'client-only-stub') &&
 		typeof value.serverRpc === 'boolean' &&
+		(value.resourceQuery === undefined || typeof value.resourceQuery === 'string') &&
+		(value.independentWidgets === undefined || Array.isArray(value.independentWidgets)) &&
 		(value.clientReference === undefined || nestedReferenceValid) &&
 		(value.universalRuntime === undefined || universalRuntimeValid)
 	) {

package/src/streamed-signals-hmr.js

@@ -0,0 +1,59 @@
+/**
+ * Fence feature-bearing documents through Rspack's native module-execution
+ * interceptor, before authored factories run. No compiled source is rewritten.
+ * @param {import('@rspack/core').Compiler} compiler
+ * @param {import('@rspack/core').Compilation} compilation
+ * @param {Array<{ module: import('@rspack/core').Module, executableModule?: import('@rspack/core').Module }>} modules
+ */
+export function createStreamedSignalHmrRuntimeModule(compiler, compilation, modules) {
+	const { RuntimeGlobals, RuntimeModule } = compiler.webpack;
+	return new (class extends RuntimeModule {
+		constructor() {
+			super('octane streamed signal HMR fence', RuntimeModule.STAGE_TRIGGER);
+		}
+
+		generate() {
+			const ids = new Set();
+			for (const { module, executableModule } of modules) {
+				for (const candidate of [executableModule, module, module?.rootModule]) {
+					const id = candidate == null ? null : compilation.chunkGraph.getModuleId(candidate);
+					if (id != null) {
+						ids.add(String(id));
+						break;
+					}
+				}
+			}
+			return `
+var octaneSignalModules = new Set(${JSON.stringify([...ids].sort())});
+var octaneSignalFenceInstalled = false;
+var octaneSignalGenerationChanged = false;
+var octaneSignalModuleExecuted = false;
+function octaneReloadSignalDocument() {
+  ${RuntimeGlobals.global}.location?.reload?.();
+  throw new Error('[octane] The streamed signal client build changed. Reload this document.');
+}
+function octaneTrackSignalGeneration(hot) {
+  if (!hot || octaneSignalFenceInstalled) return;
+  octaneSignalFenceInstalled = true;
+  if (hot.status() !== 'idle') octaneSignalGenerationChanged = true;
+  hot.addStatusHandler(function(status) {
+    if (status === 'apply') octaneSignalGenerationChanged = true;
+    if (octaneSignalModuleExecuted && (status === 'check' || status === 'dispose' || status === 'apply')) octaneReloadSignalDocument();
+  });
+}
+// A newly introduced runtime may itself arrive during hot application. The
+// entry's cached hot module supplies that state before any feature executes.
+for (var octaneCachedId in ${RuntimeGlobals.moduleCache}) {
+  octaneTrackSignalGeneration(${RuntimeGlobals.moduleCache}[octaneCachedId].hot);
+  if (octaneSignalFenceInstalled) break;
+}
+${RuntimeGlobals.interceptModuleExecution}.push(function(options) {
+  var hot = options.module.hot;
+  octaneTrackSignalGeneration(hot);
+  if (!hot || !octaneSignalModules.has(String(options.id))) return;
+  if (octaneSignalGenerationChanged || hot.status() !== 'idle') octaneReloadSignalDocument();
+  octaneSignalModuleExecuted = true;
+});`;
+		}
+	})();
+}

package/src/text-types.js

@@ -0,0 +1,62 @@
+/**
+ * Type analysis is an opt-in production build concern. Keep TypeScript out of
+ * the ordinary loader's module graph and retain one project per compiler and
+ * renderer configuration, rather than one TypeScript Program per module.
+ */
+// Rspack loads the plugin from its application's module graph and the loader
+// through its loader runner. Those can instantiate this ESM module separately
+// (for example under Vitest), even though both receive the same compiler.
+// Keep the project on that compiler under a process-wide symbol instead of in
+// module-local state. Typed builds use the main-thread loader.
+const COMPILER_TEXT_TYPES = Symbol.for('@octanejs/rspack-plugin/text-types/v1');
+
+function compilerState(compiler) {
+	return compiler?.[COMPILER_TEXT_TYPES];
+}
+
+export function registerTextTypeCompiler(compiler, tsconfig, root) {
+	if (compilerState(compiler)) {
+		throw new Error('@octanejs/rspack-plugin: only one text type project may own a compiler.');
+	}
+	Object.defineProperty(compiler, COMPILER_TEXT_TYPES, {
+		value: { tsconfig, root, projects: new Map(), closed: false },
+		configurable: true,
+	});
+}
+
+export function invalidateTextTypeCompiler(compiler) {
+	const state = compilerState(compiler);
+	if (!state || state.closed) return;
+	for (const project of state.projects.values()) project.invalidate();
+}
+
+export function disposeTextTypeCompiler(compiler) {
+	const state = compilerState(compiler);
+	if (!state) return;
+	state.closed = true;
+	for (const project of state.projects.values()) project.dispose();
+	state.projects.clear();
+	delete compiler[COMPILER_TEXT_TYPES];
+}
+
+export async function textTypeFactsForLoader(compiler, tsconfig, renderers, filename, source) {
+	const state = compilerState(compiler);
+	if (!state || state.tsconfig !== tsconfig || state.closed) {
+		throw new Error(
+			'@octanejs/rspack-plugin: `textTypes` requires the OctaneRspackPlugin on the same compiler.',
+		);
+	}
+	// The optional TypeScript peer and Volar adapter are loaded only by an opted-in
+	// production compiler. import() also shares its module initialization across
+	// concurrently built modules without retaining a checker in loader options.
+	const { createTextTypeProject } = await import('octane/compiler/typescript');
+	if (state.closed)
+		throw new Error('@octanejs/rspack-plugin: compiler closed during type analysis.');
+	const key = renderers?.signature ?? 'dom';
+	let project = state.projects.get(key);
+	if (!project) {
+		project = createTextTypeProject({ tsconfig, root: state.root, renderers });
+		state.projects.set(key, project);
+	}
+	return project.snapshot(filename, source);
+}

package/types/index.d.ts

@@ -1,5 +1,5 @@
 import type { Compiler, RspackPluginInstance } from '@rspack/core';
-import type { OctaneCssModuleConstants } from 'octane/compiler';
+import type { KnownAttributeSpread, OctaneCssModuleConstants } from 'octane/compiler';
 
 export type { OctaneCssModuleConstants } from 'octane/compiler';
 
@@ -144,8 +144,8 @@ export interface OctaneRspackLoaderOptions {
 	 * @default false
 	 */
 	strong?: boolean;
-	/** Experimental native signal reads in DOM client/server render scopes. */
-	nativeReads?: boolean;
+	/** Fixed native-attribute shapes for trusted imported spread helpers. */
+	knownAttributeSpreads?: readonly KnownAttributeSpread[];
 	/**
 	 * Path fragments excluded from the plain `.ts`/`.js` hook-slot pass. With
 	 * `requireDirective`, excluded paths are exempt from Octane ownership
@@ -177,6 +177,19 @@ export interface OctaneRspackLoaderOptions {
 }
 
 export interface OctaneRspackPluginOptions extends OctaneRspackLoaderOptions {
+	/** Build intent for SSR metadata; independent of optimization/HMR settings. */
+	clientBuildMode?: 'production' | 'development';
+	/**
+	 * @experimental Prove primitive DOM text children from the TypeScript project
+	 * in one-shot production builds. Relative paths resolve from the plugin root.
+	 * Requires the optional TypeScript peer. Uses one main-thread checker per
+	 * compiler, and typed modules bypass Rspack's persistent module cache so
+	 * imported type edits are observed on the next build. Watch/HMR and
+	 * development builds retain syntax-only classification. Configure the same
+	 * tsconfig and renderers for browser and server compilation.
+	 * @default undefined
+	 */
+	textTypes?: { tsconfig: string };
 	/**
 	 * @experimental Fold proven CSS-module strings in one-shot production builds.
 	 * `true` accepts only pure, initialized named ESM string exports. A provider
@@ -217,8 +230,25 @@ export interface OctaneRspackPluginOptions extends OctaneRspackLoaderOptions {
 
 export interface OctaneRspackBuildInfo {
 	canonicalId: string;
+	/** Resource query retained separately from the canonical source identity. */
+	resourceQuery?: string;
 	transformKind: 'compile' | 'slots' | 'client-only-stub';
+	streamedSignals?: true;
 	serverRpc: boolean;
+	/** Strict-independent Hydrate templates completed into the emitted client manifest. */
+	independentWidgets?: readonly {
+		readonly version: 1;
+		readonly boundaryId: string;
+		readonly moduleId: string;
+		readonly exportName: string;
+		readonly request: string;
+		readonly captureSchema: readonly { readonly name: string; readonly type: 'json' }[];
+		readonly hookSeed: number;
+		readonly idSeed: number;
+		readonly signalSites: readonly string[];
+		readonly styles: readonly string[];
+		readonly parentDependencies: false;
+	}[];
 	/** Universal host runtime/thread identity, when this module was specialized. */
 	universalRuntime?: OctaneUniversalRuntimeOptions;
 	/** Stable identity shared by the client compile and its inert server stub. */