octane 0.16.6 → 0.16.7

package/dist/cjs/runtime/engine.cjs

@@ -2293,9 +2293,45 @@ function flushSync(fn) {
   if (import_drivers.CONTROLLED_RESTORE_DRIVER) import_drivers.CONTROLLED_RESTORE_DRIVER.restore();
   return result;
 }
+const DETACHES_BY_TARGET = /* @__PURE__ */ new Map();
+function dropUncommittedRefPairs(detaches) {
+  const byTarget = DETACHES_BY_TARGET;
+  for (let i = 0; i < detaches.length; i += 4) {
+    const queued = byTarget.get(detaches[i + 1]);
+    if (queued === void 0) byTarget.set(detaches[i + 1], i);
+    else if (typeof queued === "number") byTarget.set(detaches[i + 1], [queued, i]);
+    else queued.push(i);
+  }
+  let write = 0;
+  for (let read = 0; read < refAttachQueue.length; read++) {
+    const entry = refAttachQueue[read];
+    const queued = byTarget.get(entry.el);
+    if (queued !== void 0) {
+      const live = entry.ref === attachLiveFragmentRef && (import_drivers.activityRefState ? import_drivers.activityRefState.get(entry.el)?.connected : null) == null;
+      if (typeof queued === "number") {
+        if (live || detaches[queued] === entry.ref) {
+          detaches[queued] = null;
+          byTarget.delete(entry.el);
+          continue;
+        }
+      } else {
+        const k = live ? 0 : queued.findIndex((i) => detaches[i] === entry.ref);
+        if (k !== -1 && k < queued.length) {
+          detaches[queued[k]] = null;
+          queued.splice(k, 1);
+          continue;
+        }
+      }
+    }
+    refAttachQueue[write++] = entry;
+  }
+  refAttachQueue.length = write;
+  byTarget.clear();
+}
 function drainQueuedRefDetaches() {
   if (import_refs.refDetachQueue.length === 0) return;
   const q = import_refs.refDetachQueue.splice(0);
+  if (refAttachQueue.length !== 0) dropUncommittedRefPairs(q);
   for (let i = 0; i < q.length; i += 4) {
     try {
       REF_CALLBACK_DEPTH++;

package/dist/cjs/runtime/hooks.cjs

@@ -507,7 +507,11 @@ function readReducerHook(reducer, initialArg, initOrSlot, slot) {
 function __useReducerWithGetter(reducer, initialArg, initOrSlot, slot) {
   const s = readReducerHook(reducer, initialArg, initOrSlot, slot);
   const getter = s.getter ??= () => latestHookValue(s, s.reducer);
-  return [s.queue === null ? s.value : foldHookQueue(s, reducer), s.dispatch, getter];
+  return [
+    s.queue === null ? s.value : foldHookQueue(s, reducer),
+    s.dispatch,
+    getter
+  ];
 }
 function depsChanged(prev, next, hook = false) {
   if (prev === void 0 || next === void 0) return true;

package/dist/cjs/runtime/portals.cjs

@@ -330,18 +330,19 @@ function renderPortalState(prev, parentBlock, target, rawBody, rawProps, host, e
       state.start.$$portalParent = host;
     }
     state.host = host;
-    if (state.block.body !== norm.body)
-      (0, import_engine.journalRootProperty)(state.block, "body", state.block.body);
-    if (state.block.props !== norm.props)
-      (0, import_engine.journalRootProperty)(state.block, "props", state.block.props);
-    if (state.block.extra !== env) (0, import_engine.journalRootProperty)(state.block, "extra", state.block.extra);
-    state.block.body = norm.body;
-    state.block.props = norm.props;
-    state.block.extra = env;
-    if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
-      (0, import_profiling.__profileTrackComponent)(state.block, (0, import_profile_probes.profilePortalComponent)(rawBody, norm.body));
+    const block = state.block;
+    if (!(import_drivers.MEMO_BAIL && block.body === norm.body && (0, import_drivers.MEMO_BAIL)(block, norm.body, norm.props))) {
+      if (block.body !== norm.body) (0, import_engine.journalRootProperty)(block, "body", block.body);
+      if (block.props !== norm.props) (0, import_engine.journalRootProperty)(block, "props", block.props);
+      if (block.extra !== env) (0, import_engine.journalRootProperty)(block, "extra", block.extra);
+      block.body = norm.body;
+      block.props = norm.props;
+      block.extra = env;
+      if (typeof __OCTANE_PROFILE_ENABLED__ !== "undefined" && __OCTANE_PROFILE_ENABLED__) {
+        (0, import_profiling.__profileTrackComponent)(block, (0, import_profile_probes.profilePortalComponent)(rawBody, norm.body));
+      }
+      (0, import_signal_owners.renderBlock)(block);
     }
-    (0, import_signal_owners.renderBlock)(state.block);
   }
   let n = (0, import_templates.getNextSibling)(state.start);
   if (state.interleavedFragment === void 0) {

package/dist/cjs/version.cjs

@@ -21,7 +21,7 @@ __export(version_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(version_exports);
-const version = "0.16.6";
+const version = "0.16.7";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/compiler/bundler.d.ts

@@ -0,0 +1,306 @@
+import type {
+	CompileDiagnostic,
+	CompileOptions,
+	CompileResult,
+	CompilerProgram,
+	CompileSourceMap,
+	OctaneCssModuleConstants,
+} from './index.js';
+import type {
+	OctaneRendererConfigOptions,
+	OctaneResolvedRenderer,
+	OctaneResolvedRendererConfig,
+} from './renderers.js';
+
+export { DOM_BINDING_COMPILER_ABI_VERSION } from './index.js';
+export {
+	DOM_RENDERER_ID,
+	DOM_RENDERER_MODULE,
+	RENDERER_CONFIG_VERSION,
+	normalizeRendererConfig,
+	resolveRendererForFile,
+} from './renderers.js';
+export type {
+	OctaneRendererConfigOptions,
+	OctaneResolvedRenderer,
+	OctaneResolvedRendererConfig,
+} from './renderers.js';
+export { findVoidComponentImports, findVoidRootImports } from './slot-hooks.js';
+export type { VoidComponentImport } from './slot-hooks.js';
+
+export type OctaneEnvironment = 'client' | 'server';
+
+/** Options for one compiler instance; `transform` may override the per-module ones. */
+export interface OctaneCompilerOptions extends Pick<
+	CompileOptions,
+	'knownAttributeSpreads' | 'domBindingFixedProps' | 'opaqueSignalHandles' | 'universalRuntime'
+> {
+	/** Project root for canonical module IDs and package-manifest discovery. @default process.cwd() */
+	root?: string;
+	/** @default 'client' */
+	environment?: OctaneEnvironment;
+	/** Opt into a typed compiler intermediate. The host emits JavaScript and composes maps. */
+	output?: 'js' | 'ts';
+	/** HMR code generation dialect; `true` means `'vite'`. Server transforms never emit HMR. */
+	hmr?: boolean | 'vite' | 'webpack';
+	/** Client development metadata. Defaults on whenever client HMR is on. */
+	dev?: boolean;
+	/** Component profiling metadata in client transforms. */
+	profile?: boolean;
+	/** @default true */
+	inlineHookMemo?: boolean;
+	/**
+	 * Assert pure immutable-snapshot renders in application-owned modules.
+	 * Individual modules can opt in with a top-level `"use strong"` directive.
+	 * @default false
+	 */
+	strong?: boolean;
+	/** Path fragments excluded from Octane's plain `.ts`/`.js` hook-slot pass. */
+	exclude?: readonly string[];
+	/**
+	 * Mixed-toolchain ownership gate: a project `.tsx`, `.ts`, or `.js` module is
+	 * Octane's only with a leading `@jsxImportSource octane` pragma.
+	 * @default false
+	 */
+	requireDirective?: boolean;
+	/** @experimental Declarative renderer selection for this compiler instance. */
+	renderers?: OctaneRendererConfigOptions | OctaneResolvedRendererConfig;
+	/** Receives ownership warnings and nonfatal compiler diagnostics, once per watch generation. */
+	warn?: (message: string) => void;
+}
+
+export interface OctaneTransformOptions
+	extends
+		Pick<
+			OctaneCompilerOptions,
+			| 'environment'
+			| 'output'
+			| 'hmr'
+			| 'dev'
+			| 'profile'
+			| 'inlineHookMemo'
+			| 'strong'
+			| 'knownAttributeSpreads'
+			| 'domBindingFixedProps'
+			| 'opaqueSignalHandles'
+			| 'universalRuntime'
+		>,
+		Pick<
+			CompileOptions,
+			| 'textTypeFacts'
+			| 'clientOnlyImports'
+			| 'resolveCssModuleConstant'
+			| 'preserveCssModuleReferences'
+			| 'isVoidComponentImport'
+			| 'isCompilerMemoImport'
+			| 'isLiteComponentImport'
+			| 'isStrongLiteComponentImport'
+			| 'isAnchorlessComponentImport'
+			| 'isDescriptorChildrenImport'
+		> {
+	/** Rewrite server runtime requests (`octane` to `octane/server`) in the output. */
+	explicitRuntimeRequests?: boolean;
+	/** Report `voidComponentExports` for a compiled client module. */
+	collectVoidComponentExports?: boolean;
+}
+
+/** Manifests that decided a result; a host registers them as watch dependencies. */
+export interface OctaneWatchDependencies {
+	dependencies: string[];
+	missingDependencies: string[];
+}
+
+/** Server-graph identity of a module owned by a client-only renderer. */
+export interface OctaneClientReference {
+	readonly id: string;
+	readonly moduleId: string;
+	readonly renderer: string;
+}
+
+export interface OctaneTransformResult
+	extends
+		OctaneWatchDependencies,
+		Pick<
+			CompileResult,
+			'lang' | 'streamedSignals' | 'universalRuntime' | 'compilerMemoExports' | 'bindingConstants'
+		> {
+	code: string;
+	map: CompileSourceMap | null;
+	/**
+	 * `compile`: full Octane compilation. `slots`: hook slotting of a plain
+	 * module. `client-only-stub`: an export-preserving server stub.
+	 * `runtime-requests`: only runtime requests were rewritten. `none`: the
+	 * source is unchanged and returned only to report watch dependencies.
+	 */
+	kind: 'compile' | 'slots' | 'client-only-stub' | 'runtime-requests' | 'none';
+	diagnostics?: readonly CompileDiagnostic[];
+	renderer?: OctaneResolvedRenderer;
+	clientReference?: OctaneClientReference;
+	/** Export names of a client-only server stub. */
+	clientOnlyExports?: readonly string[];
+	/** The printed client-only server stub. */
+	ast?: CompilerProgram;
+	// Build-time metadata adapters publish to importers of this module.
+	descriptorChildrenExports?: readonly string[];
+	voidComponentExports?: readonly string[];
+	liteComponentExports?: readonly string[];
+	strongLiteComponentExports?: readonly string[];
+	anchorlessComponentExports?: readonly string[];
+	cssModuleConstantImports?: readonly unknown[];
+	independentWidgets?: readonly unknown[];
+}
+
+export interface OctaneSourceDependencies extends OctaneWatchDependencies {
+	/** Installed packages that ship Octane source, following their runtime dependencies. */
+	packages: string[];
+	/** Package IDs those packages ask Vite not to pre-bundle. */
+	viteOptimizeDepsExclusions: string[];
+}
+
+/** The bundler-neutral compiler that every Octane bundler adapter drives. */
+export interface OctaneCompiler {
+	/**
+	 * Compile or hook-slot one module, or return `null` when it passes through
+	 * unchanged with no watch dependencies.
+	 */
+	transform(
+		code: string,
+		id: string,
+		options?: OctaneTransformOptions,
+	): OctaneTransformResult | null;
+	/** Clear cached manifest decisions after a watched path changes, or all of them. */
+	invalidate(path?: string | null): void;
+	discoverSourceDependencies(): OctaneSourceDependencies;
+	/** The privacy-safe source identity used by profiling metadata. */
+	resolveProfileModuleId(id: string): OctaneWatchDependencies & { id: string };
+	resolveRuntimeRequest(request: string, environment?: OctaneEnvironment): string | null;
+	/** Static requests an adapter resolves before a server transform. */
+	findServerImportRequests(code: string, id: string): string[];
+	/** CSS-module requests the host may prove constant, behind the same ownership gate. */
+	findCssModuleImportRequests(
+		code: string,
+		id: string,
+		environment?: OctaneEnvironment,
+		parsedAst?: CompilerProgram | null,
+	): string[];
+	/** Classify a bundler-resolved module without loading or evaluating it. */
+	clientReferenceForFile(id: string): OctaneClientReference | null;
+	/** How Strong mode reaches a module: its own directive, the `strong` option, or neither. */
+	strongModuleStatus(
+		code: string,
+		id: string,
+	): {
+		strong: boolean;
+		directive: boolean;
+		config: boolean;
+	};
+	/** The package owning a module by its nearest manifest, and whether `transform` may change it. */
+	modulePackage(
+		code: string,
+		id: string,
+	): {
+		name: string | null;
+		root: string | null;
+		compiled: boolean;
+	};
+}
+
+export function createOctaneCompiler(options?: OctaneCompilerOptions): OctaneCompiler;
+
+/** Discover raw-source Octane dependencies from the nearest owning package manifest. */
+export function discoverOctaneSourceDependencies(projectRoot: string): string[];
+
+export const OCTANE_RUNTIME_REQUESTS: Readonly<{ client: 'octane'; server: 'octane/server' }>;
+
+/** The server or client runtime request for an Octane runtime import, or `null` for any other. */
+export function resolveOctaneRuntimeRequest(
+	request: string,
+	environment: OctaneEnvironment,
+): string | null;
+
+/** Strip bundler query/hash suffixes without changing the underlying path. */
+export function cleanModuleId(id: string): string;
+
+/** The stable module ID embedded in compiler output: root-relative POSIX inside the root. */
+export function canonicalModuleId(id: string, projectRoot?: string): string;
+
+/** Whether an installed package reaches, through non-Octane packages, one Vite serves as CommonJS. */
+export function packageReachesCommonJs(root: string): boolean;
+
+/** Read the module specifier of a leading `@jsxImportSource` pragma. */
+export function findLeadingJsxImportSourcePragma(code: string): string | null;
+
+export const HYDRATE_QUERY_PARAM: 'octane-hydrate';
+export const INDEPENDENT_HYDRATION_MANIFEST_FILENAME: 'octane-independent-hydration.json';
+
+/** Direct function exports whose authored body never returns a renderable value. */
+export function findVoidComponentExports(source: string | CompilerProgram, id: string): string[];
+
+/** Facts about a module's final JavaScript after every bundler transform, or `null` if it does not parse. */
+export function analyzeCompiledModule(
+	source: string,
+	id: string,
+): {
+	voidComponentExports: string[];
+	/** `imported` is `default` or `*` for those import forms. */
+	importBindings: { local: string; request: string; imported: string }[];
+} | null;
+
+export function findDescriptorChildrenExports(
+	source: string | CompilerProgram,
+	id: string,
+): string[];
+
+/** Imported components rendered as JSX or re-exported, as descriptor-children candidates. */
+export function findDescriptorChildrenImports(
+	source: string | CompilerProgram,
+	id: string,
+): { request: string; imported: string; local?: string; exported?: string }[];
+
+export function isPlainCssModuleId(id: string): boolean;
+
+/** A CSS provider's literal string exports, read without running it. */
+export interface OctaneCssModuleExports {
+	named: Map<string, string>;
+	default: Map<string, string> | null;
+	pure: boolean;
+}
+
+export function readCssModuleExports(
+	source: string,
+	options?: { allowPureVar?: boolean },
+): OctaneCssModuleExports | null;
+
+/** Validate a host assertion against the exact module it describes; throws when it does not hold. */
+export function validateCssModuleConstants(
+	provided: OctaneCssModuleConstants | null | undefined,
+	exports: OctaneCssModuleExports | null,
+	id: string,
+	diagnosticOwner?: string,
+): { named: Map<string, string>; default: Map<string, string> } | null;
+
+/**
+ * Fail-closed check of a `hydrate: 'islands'` shell: constructs that need
+ * client work, and the imported components to check the same way.
+ */
+export function analyzeIslandsShell(
+	source: string,
+	filename: string,
+	exports?: readonly string[] | null,
+	options?: { values?: boolean },
+): {
+	problems: { message: string; line: number; column: number }[];
+	components: { source: string; exportName: string; value?: true }[];
+};
+
+export const CLIENT_REFERENCE_MANIFEST_FILENAME: 'octane-client-references.json';
+export const CLIENT_REFERENCE_MANIFEST_VERSION: 1;
+
+/** Merge the chunks each adapter found for client references into one deterministic manifest. */
+export function createClientReferenceManifest(
+	entries:
+		Iterable<{ reference: OctaneClientReference; chunks?: Iterable<string> }> | null | undefined,
+): {
+	version: typeof CLIENT_REFERENCE_MANIFEST_VERSION;
+	references: Record<string, { moduleId: string; renderer: string; chunks: string[] }>;
+};

package/dist/compiler/bundler.js

@@ -265,6 +265,57 @@ function realPathOrSelf(dir) {
 	}
 }
 
+/**
+ * Whether Vite would serve this package as CommonJS: its entry is a `.js` or
+ * `.cjs` file outside a `"type": "module"` scope, and neither a `module` field
+ * nor an `import` condition offers ESM.
+ */
+function servesCommonJs(pkg) {
+	if (pkg.type === 'module' || typeof pkg.module === 'string') return false;
+	const exports = JSON.stringify(pkg.exports ?? null);
+	if (/"(?:import|module)":|\.mjs"/.test(exports)) return false;
+	return (
+		/\.c?js"/.test(exports) ||
+		(typeof pkg.main === 'string' && /(?:^|\/)[^./]+$|\.c?js$/.test(pkg.main))
+	);
+}
+
+/**
+ * Whether the installed package at `root` depends, through packages other than
+ * Octane source packages, on one Vite would serve as CommonJS. Reads manifests
+ * only: the package's dependencies and peers, then their dependencies.
+ */
+export function packageReachesCommonJs(root) {
+	const unwatched = { dependencies: new Set(), missingDependencies: new Set() };
+	const seen = new Set();
+	const pending = [root];
+	while (pending.length > 0) {
+		const dir = pending.pop();
+		if (seen.has(dir)) continue;
+		seen.add(dir);
+		let pkg;
+		try {
+			pkg = JSON.parse(nodeFs.readFileSync(nodePath.join(dir, 'package.json'), 'utf8'));
+		} catch {
+			continue;
+		}
+		if (dir !== root) {
+			if (packageUsesOctane(pkg, dir)) continue;
+			if (servesCommonJs(pkg)) return true;
+		}
+		for (const name of Object.keys({
+			...(dir === root ? pkg.peerDependencies : null),
+			...pkg.dependencies,
+			...pkg.optionalDependencies,
+		})) {
+			if (name.startsWith('@types/')) continue;
+			const manifest = resolveInstalledPackageManifest(name, dir, unwatched);
+			if (manifest !== null) pending.push(realPathOrSelf(nodePath.dirname(manifest)));
+		}
+	}
+	return false;
+}
+
 function metadata(dependencies = [], missingDependencies = []) {
 	return { dependencies, missingDependencies };
 }
@@ -998,7 +1049,7 @@ class OctaneBundlerCompiler {
 		return isPathInside(this.root, absoluteFile) || isPathInside(this.realRoot, absoluteFile);
 	}
 
-	_hasApplicationStrongPolicy(file, collected) {
+	_isApplicationSource(file, collected) {
 		if (!this._isProjectOwnedSource(file)) return false;
 		const absoluteFile = nodePath.isAbsolute(file)
 			? nodePath.resolve(file)
@@ -1031,7 +1082,7 @@ class OctaneBundlerCompiler {
 		const file = cleanModuleId(id);
 		const config =
 			this.defaults.strong === true &&
-			this._hasApplicationStrongPolicy(file, {
+			this._isApplicationSource(file, {
 				dependencies: new Set(),
 				missingDependencies: new Set(),
 			});
@@ -1567,7 +1618,7 @@ class OctaneBundlerCompiler {
 		// directive, which the authored-source compiler resolves separately.
 		const strong =
 			(options.strong ?? this.defaults.strong) === true &&
-			this._hasApplicationStrongPolicy(file, collected);
+			this._isApplicationSource(file, collected);
 		const universalRuntime = normalizeUniversalRuntime(
 			options.universalRuntime ?? this.defaults.universalRuntime,
 		);
@@ -1816,7 +1867,6 @@ class OctaneBundlerCompiler {
 				}
 				return passThrough();
 			}
-			const hasHookRuntimeImport = importsHookRuntime(code);
 			// Hook slotting is an Octane-ownership rewrite, so the ownership
 			// gate applies to it exactly as to full compilation: an unmarked
 			// project module stays with the host pipeline (with the forgotten-
@@ -1826,13 +1876,19 @@ class OctaneBundlerCompiler {
 				return passThrough();
 			}
 			const manualSlots = this._hasManualHookSlots(file, collected);
-			if (
-				!hasHookRuntimeImport &&
-				!manualSlots &&
-				!pragmaOwned &&
-				!this._pragmaClaimsOwnership(code)
-			)
-				return passThrough();
+			// The application's own modules are Octane's, as its `.tsx` are, so they
+			// slot custom-hook calls without importing Octane: a hook composed only
+			// of other hooks keeps one instance per call. A package, installed or
+			// nested in the root, still needs the import or pragma, since its plain
+			// modules may implement hooks with authored slots, as Octane's runtime does.
+			// A leading pragma decides for itself: one naming `react` hands the
+			// module to that toolchain.
+			const pragma = findLeadingJsxImportSourcePragma(code);
+			const owned =
+				pragma === null
+					? this._isApplicationSource(file, collected)
+					: this.pragmaOwnedModules.has(pragma);
+			if (!importsHookRuntime(code) && !manualSlots && !owned) return passThrough();
 			if (output === 'ts' && !manualSlots) {
 				// The cheap ownership regex also matches documentation examples. A
 				// full compile needs a real import (or an explicit ownership pragma).
@@ -1878,7 +1934,7 @@ class OctaneBundlerCompiler {
 				profile,
 				profileFilename,
 				inlineHookMemo: inlinePlainMemo,
-				...(manualSlots ? { manualSlots: true } : null),
+				...(manualSlots ? { manualSlots: true } : owned ? { owned: true } : null),
 				...(strong ? { strong: true } : null),
 				renderer,
 				...(specializeVoidRoot

package/dist/compiler/compile.js

@@ -10434,6 +10434,82 @@ function dropTypeOnlyStatements(body) {
 	return typeNames.size === 0 ? result : dropTypeOnlyExports(result, typeNames);
 }
 
+const TYPESCRIPT_SOURCE = /\.(?:tsrx|[cm]?tsx?)$/;
+
+// The runtime emit erases what tsc does. Without `verbatimModuleSyntax` that
+// includes an import specifier written without `type` when the module refers
+// to it only in type positions, and a declaration left with none. Such a
+// specifier usually names only a type, so keeping it imports an export that
+// does not exist, which Rolldown rejects. A specifier nothing refers to stays,
+// as in JavaScript: a pass before this one may have added an import whose reads
+// it emits later (renderer regions).
+function dropTypeOnlyCode(body, filename) {
+	const runtime = dropTypeOnlyStatements(body);
+	if (!TYPESCRIPT_SOURCE.test(cleanCompileFilename(filename))) return runtime;
+	const reads = collectFreeIdentifiers(
+		runtime.filter((statement) => statement.type !== 'ImportDeclaration'),
+		[],
+	);
+	const unread = (specifier) => !reads.has(specifier.local.name);
+	if (
+		!runtime.some(
+			(statement) => statement.type === 'ImportDeclaration' && statement.specifiers.some(unread),
+		)
+	) {
+		return runtime;
+	}
+	// Erased declarations refer to types too, as in `interface Props { icon: Icon }`.
+	const types = collectTypeReferenceNames(body, new Set());
+	const result = [];
+	for (const statement of runtime) {
+		if (statement.type !== 'ImportDeclaration') {
+			result.push(statement);
+			continue;
+		}
+		const specifiers = statement.specifiers.filter(
+			(specifier) => !unread(specifier) || !types.has(specifier.local.name),
+		);
+		if (specifiers.length === statement.specifiers.length) result.push(statement);
+		else if (specifiers.length > 0) result.push({ ...statement, specifiers });
+	}
+	return result;
+}
+
+// The root name of every type reference: `T`, `ns.T`, `typeof value`, the
+// heritage of `implements` and interface `extends`, and a local exported with
+// `export type { T }` or `export { type T }`.
+function collectTypeReferenceNames(node, names) {
+	if (node === null || typeof node !== 'object') return names;
+	if (Array.isArray(node)) {
+		for (const child of node) collectTypeReferenceNames(child, names);
+		return names;
+	}
+	let name =
+		node.type === 'TSTypeReference'
+			? node.typeName
+			: node.type === 'TSTypeQuery'
+				? node.exprName
+				: node.type === 'TSClassImplements' ||
+					  node.type === 'TSInterfaceHeritage' ||
+					  node.type === 'TSExpressionWithTypeArguments'
+					? node.expression
+					: null;
+	while (name?.type === 'TSQualifiedName') name = name.left;
+	while (name?.type === 'MemberExpression') name = name.object;
+	if (name?.type === 'Identifier') names.add(name.name);
+	if (node.type === 'ExportNamedDeclaration' && node.source == null) {
+		for (const specifier of node.specifiers) {
+			if (node.exportKind === 'type' || specifier.exportKind === 'type') {
+				names.add(specifier.local.name);
+			}
+		}
+	}
+	for (const key in node) {
+		if (!AST_WALK_SKIP_KEYS.has(key)) collectTypeReferenceNames(node[key], names);
+	}
+	return names;
+}
+
 // Local names declared only by an erased statement or specifier.
 function collectTypeOnlyNames(statement, names) {
 	const node = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
@@ -12549,9 +12625,9 @@ function compileInternal(
 	}
 	// Drop type-only statements (interface / type / declare / import-export type)
 	// and inline `type` specifiers before emit — they carry no runtime value and
-	// would leak invalid TS into the .js (or crash the printer). Runtime-only;
-	// Volar keeps them.
-	if (options?.output !== 'ts') ast = { ...ast, body: dropTypeOnlyStatements(ast.body) };
+	// would leak invalid TS into the .js (or crash the printer), then imports
+	// used only as types, as tsc elides them. Runtime-only; Volar keeps them.
+	if (options?.output !== 'ts') ast = { ...ast, body: dropTypeOnlyCode(ast.body, filename) };
 	const serverModuleInfo = analyzeServerModule(ast, filename);
 	// Normalize arrow-function components (`const X = () => @{…}`) to
 	// FunctionDeclaration form so the component pipeline recognizes them.
@@ -14341,9 +14417,9 @@ function compileServer(
 	// server codegen rewrites are copy-on-write over it.
 	let ast = parsedAst;
 	// Drop type-only statements and inline `type` specifiers before emit (see
-	// isTypeOnlyStatement) — same as the client path; the server HTML-string
-	// output is plain JS too.
-	if (options?.output !== 'ts') ast = { ...ast, body: dropTypeOnlyStatements(ast.body) };
+	// isTypeOnlyStatement), then imports used only as types — same as the client
+	// path; the server HTML-string output is plain JS too.
+	if (options?.output !== 'ts') ast = { ...ast, body: dropTypeOnlyCode(ast.body, filename) };
 	const serverModuleInfo = analyzeServerModule(ast, filename);
 	// Normalize arrow-function components (`const X = () => @{…}`) to
 	// FunctionDeclaration form so the component pipeline recognizes them.
@@ -17023,7 +17099,9 @@ function ssrEmitComponent(node, ctx, name, inlinedSubs, parentNs, cssHash, compo
 	let keyExpr = null;
 	for (const attr of attrs) {
 		if (attr.type === 'SpreadAttribute' || attr.type === 'JSXSpreadAttribute') {
-			propNodes.push(b.spread(tsrxExprNode(attr.argument, ctx, name, inlinedSubs)));
+			propNodes.push(
+				b.spread(tsrxExprNode(rewriteJsxValues(attr.argument, ctx), ctx, name, inlinedSubs)),
+			);
 			continue;
 		}
 		if (attr.type !== 'Attribute' && attr.type !== 'JSXAttribute') continue;
@@ -36604,7 +36682,11 @@ function makeCompCall(
 	for (const attr of attrs) {
 		if (attr.type === 'SpreadAttribute' || attr.type === 'JSXSpreadAttribute') {
 			hasSpreadProp = true;
-			propNodes.push(b.spread(tsrxExprNode(attr.argument, ctx, componentName, inlinedSubs)));
+			propNodes.push(
+				b.spread(
+					tsrxExprNode(rewriteJsxValues(attr.argument, ctx), ctx, componentName, inlinedSubs),
+				),
+			);
 			continue;
 		}
 		if (attr.type !== 'Attribute' && attr.type !== 'JSXAttribute') continue;