@octanejs/tanstack-start 0.1.1 → 0.1.2

package/src/hydration/generic.d.ts

@@ -0,0 +1,18 @@
+import type {
+	HydrationCondition,
+	HydrationInteractionEvents,
+	HydrationPrefetchStrategy,
+} from '@tanstack/start-client-core/hydration';
+import type { OctaneHydrationStrategy } from '../Hydrate.tsrx';
+
+export declare function media(
+	query: string,
+): OctaneHydrationStrategy<'media', true> & HydrationPrefetchStrategy<'media'>;
+
+export declare function condition(
+	condition: HydrationCondition,
+): OctaneHydrationStrategy<'condition', false>;
+
+export declare function interaction(options?: {
+	events?: HydrationInteractionEvents;
+}): OctaneHydrationStrategy<'interaction', true> & HydrationPrefetchStrategy<'interaction'>;

package/src/hydration/generic.js

@@ -0,0 +1,26 @@
+// media / condition / interaction hydration strategies — port of
+// @tanstack/react-start-client's hydration/generic.ts. The gating logic lives
+// in @tanstack/start-client-core; these factories just attach octane's
+// GenericHydrate renderer.
+import {
+	condition as coreCondition,
+	interaction as coreInteraction,
+	media as coreMedia,
+	withHydrationRenderer,
+} from '@tanstack/start-client-core/hydration';
+import { GenericHydrate } from '../GenericHydrate.tsrx';
+
+/* @__NO_SIDE_EFFECTS__ */
+export function media(query) {
+	return /* @__PURE__ */ withHydrationRenderer(coreMedia(query), GenericHydrate);
+}
+
+/* @__NO_SIDE_EFFECTS__ */
+export function condition(condition) {
+	return /* @__PURE__ */ withHydrationRenderer(coreCondition(condition), GenericHydrate);
+}
+
+/* @__NO_SIDE_EFFECTS__ */
+export function interaction(options) {
+	return /* @__PURE__ */ withHydrationRenderer(coreInteraction(options), GenericHydrate);
+}

package/src/hydration/idle.d.ts

@@ -0,0 +1,9 @@
+import type {
+	HydrationPrefetchStrategy,
+	IdleHydrationOptions,
+} from '@tanstack/start-client-core/hydration';
+import type { OctaneHydrationStrategy } from '../Hydrate.tsrx';
+
+export declare function idle(
+	options?: IdleHydrationOptions,
+): OctaneHydrationStrategy<'idle', true> & HydrationPrefetchStrategy<'idle'>;

package/src/hydration/idle.js

@@ -0,0 +1,10 @@
+// idle hydration strategy — port of @tanstack/react-start-client's
+// hydration/idle.ts. Delegates the requestIdleCallback gating to
+// @tanstack/start-client-core and attaches octane's GenericHydrate renderer.
+import { idle as coreIdle, withHydrationRenderer } from '@tanstack/start-client-core/hydration';
+import { GenericHydrate } from '../GenericHydrate.tsrx';
+
+/* @__NO_SIDE_EFFECTS__ */
+export function idle(options = {}) {
+	return /* @__PURE__ */ withHydrationRenderer(coreIdle(options), GenericHydrate);
+}

package/src/hydration/load.tsrx

@@ -0,0 +1,38 @@
+// load hydration strategy — port of @tanstack/react-start-client's
+// hydration/load.tsx. `load` hydrates immediately, so its renderer skips the
+// marker/gate machinery entirely: a bare Suspense wrapper plus an onHydrated
+// notification effect.
+import { Suspense, useEffect, useRef } from 'octane';
+import type { OctaneNode } from 'octane';
+import { load as coreLoad, withHydrationRenderer } from '@tanstack/start-client-core/hydration';
+import type { HydrateProps } from '../Hydrate.tsrx';
+
+function HydratedBoundary(props: { onHydrated?: () => void; children?: OctaneNode }) {
+	const { onHydrated } = props;
+	const didHydrateRef = useRef(false);
+
+	useEffect(() => {
+		if (didHydrateRef.current) return;
+		didHydrateRef.current = true;
+		onHydrated?.();
+	}, [onHydrated]);
+
+	return props.children;
+}
+
+// OCTANE ADAPTATION: octane's `Hydrate` renders `_h` as a child component
+// (upstream bare-calls it inline); LoadHydrate is that component.
+export function LoadHydrate(props: HydrateProps) @{
+	<div>
+		<Suspense fallback={props.fallback ?? null}>
+			<HydratedBoundary onHydrated={props.onHydrated}>{props.children}</HydratedBoundary>
+		</Suspense>
+	</div>
+}
+
+const loadStrategy = /* @__PURE__ */ withHydrationRenderer(coreLoad(), LoadHydrate);
+
+/* @__NO_SIDE_EFFECTS__ */
+export function load() {
+	return loadStrategy;
+}

package/src/hydration/load.tsrx.d.ts

@@ -0,0 +1,8 @@
+import type { OctaneNode } from 'octane';
+import type { HydrationPrefetchStrategy } from '@tanstack/start-client-core/hydration';
+import type { HydrateProps, OctaneHydrationStrategy } from '../Hydrate.tsrx';
+
+export declare function LoadHydrate(props: HydrateProps): OctaneNode;
+
+export declare function load(): OctaneHydrationStrategy<'load', true> &
+	HydrationPrefetchStrategy<'load'>;

package/src/hydration/never.tsrx

@@ -0,0 +1,71 @@
+// never hydration strategy — port of @tanstack/react-start-client's
+// hydration/never.tsx. Server HTML is preserved verbatim and the subtree is
+// never hydrated: the gate promise never resolves, so the Suspense boundary
+// keeps showing the saved server HTML (re-injected via dangerouslySetInnerHTML)
+// forever. `reactUse` feature-detection is dropped — octane's `use` always
+// exists.
+import { Suspense, use, useCallback, useId, useRef } from 'octane';
+import type { OctaneNode } from 'octane';
+import { useHydrated } from '@octanejs/tanstack-router';
+import { isServer } from '@tanstack/router-core/isServer';
+import { never as coreNever, withHydrationRenderer } from '@tanstack/start-client-core/hydration';
+import {
+	hydrateIdAttribute,
+	hydrateWhenAttribute,
+} from '@tanstack/start-client-core/hydration/constants';
+import { getFallbackHtml, saveFallbackHtml } from '@tanstack/start-client-core/hydration/runtime';
+import type { HydrateProps, InternalHydrateProps } from '../Hydrate.tsrx';
+
+const neverType = 'never';
+const neverPromise = new Promise<void>(() => {});
+
+function NeverGate(props: { children?: OctaneNode }) {
+	if (isServer ?? typeof window === 'undefined') {
+		return props.children;
+	}
+
+	use(neverPromise);
+
+	return props.children;
+}
+
+// OCTANE ADAPTATION: octane's `Hydrate` renders `_h` as a child component
+// (upstream bare-calls it inline); NeverHydrate is that component.
+export function NeverHydrate(props: HydrateProps) @{
+	const internalProps = props as InternalHydrateProps;
+	const hydrated = useHydrated();
+	const octaneId = useId();
+	const id = internalProps.h ? `${internalProps.h}${octaneId}` : octaneId;
+	const shouldPreserveServerHTMLRef = useRef<boolean | undefined>(undefined);
+	shouldPreserveServerHTMLRef.current ??= (isServer ?? typeof window === 'undefined') || !hydrated;
+	const markerRef = useCallback((element: HTMLDivElement | null) => {
+		if (!element) return;
+		if (!shouldPreserveServerHTMLRef.current) {
+			element.replaceChildren();
+		} else {
+			saveFallbackHtml(id, element);
+		}
+	}, [id]);
+	const savedHtml = getFallbackHtml(id);
+
+	<div
+		ref={markerRef}
+		{...{
+			[hydrateIdAttribute]: id,
+			[hydrateWhenAttribute]: neverType,
+		}}
+	>
+		<Suspense
+			fallback={savedHtml
+				? <div style={{ display: 'contents' }} dangerouslySetInnerHTML={{ __html: savedHtml }} />
+				: props.fallback ?? null}
+		>
+			<NeverGate>{props.children}</NeverGate>
+		</Suspense>
+	</div>
+}
+
+/* @__NO_SIDE_EFFECTS__ */
+export function never() {
+	return /* @__PURE__ */ withHydrationRenderer(coreNever(), NeverHydrate);
+}

package/src/hydration/never.tsrx.d.ts

@@ -0,0 +1,6 @@
+import type { OctaneNode } from 'octane';
+import type { HydrateProps, OctaneHydrationStrategy } from '../Hydrate.tsrx';
+
+export declare function NeverHydrate(props: HydrateProps): OctaneNode;
+
+export declare function never(): OctaneHydrationStrategy<'never', false>;

package/src/hydration/visible.tsrx

@@ -0,0 +1,123 @@
+// visible hydration strategy — port of @tanstack/react-start-client's
+// hydration/visible.tsx. Fully self-contained fast path (no shared gate
+// registry): a per-instance promise gate resolved by an IntersectionObserver.
+// `reactUse` feature-detection is dropped — octane's `use` always exists.
+//
+// OCTANE ADAPTATION: upstream's VisibleHydrate is bare-called as a method
+// (`props.when._h(props)`) with the strategy as `this`, running its hooks on
+// the caller's fiber. Octane's compiled components take the
+// `(props, __s, __extra)` ABI and cannot be bare-called, so octane's `Hydrate`
+// renders `_h` as a child component and VisibleHydrate derives its strategy
+// from `props.when` instead of `this` (resolving a function-valued `when` per
+// render, exactly as upstream's Hydrate does).
+import { Suspense, use, useEffect, useRef, useState } from 'octane';
+import type { OctaneNode } from 'octane';
+import { isServer } from '@tanstack/router-core/isServer';
+import type {
+	HydrationPrefetchStrategy,
+	VisibleHydrationOptions,
+} from '@tanstack/start-client-core/hydration';
+import type { HydrateProps, InternalHydrateProps, OctaneHydrationStrategy } from '../Hydrate.tsrx';
+
+type VisibleGate = {
+	p: Promise<void>;
+	r: boolean;
+	s: () => void;
+};
+
+function HydrationBoundary(props: { g: VisibleGate; o?: () => void; children?: OctaneNode }) {
+	const { g, o } = props;
+
+	if (!g.r) {
+		use(g.p);
+	}
+
+	useEffect(() => {
+		o?.();
+	}, [o]);
+
+	return props.children;
+}
+
+export function VisibleHydrate(props: HydrateProps) @{
+	const when = props.when;
+	const strategy = (typeof when === 'function' ? when() : when) as OctaneHydrationStrategy<
+		'visible',
+		true
+	>;
+	const prefetchStrategy = props.prefetch;
+	const preload = (props as InternalHydrateProps).p;
+	const markerRef = useRef<HTMLDivElement | null>(null);
+	const [gate] = useState<VisibleGate>(() => {
+		let resolvePromise: () => void;
+		const nextGate: VisibleGate = {
+			p: new Promise<void>((resolve) => {
+				resolvePromise = resolve;
+			}),
+			r: false,
+			s: () => {
+				nextGate.r = true;
+				resolvePromise();
+			},
+		};
+		if (isServer ?? typeof window === 'undefined') {
+			nextGate.s();
+		}
+
+		return nextGate;
+	});
+
+	useEffect(() => {
+		if (!preload || typeof prefetchStrategy === 'function') {
+			return;
+		}
+
+		return prefetchStrategy?._s?.({
+			element: markerRef.current,
+			prefetch: preload,
+		});
+	}, [prefetchStrategy, preload]);
+
+	useEffect(() => {
+		if (gate.r) return;
+
+		return strategy._s?.({
+			element: markerRef.current,
+			gate: gate as never,
+		});
+	}, [gate, strategy]);
+
+	<div ref={markerRef}>
+		<Suspense fallback={props.fallback}>
+			<HydrationBoundary g={gate} o={props.onHydrated}>{props.children}</HydrationBoundary>
+		</Suspense>
+	</div>
+}
+
+/* @__NO_SIDE_EFFECTS__ */
+export function visible(
+	options?: VisibleHydrationOptions,
+): OctaneHydrationStrategy<'visible', true> & HydrationPrefetchStrategy<'visible'> {
+	const rootMargin = options?.rootMargin ?? '600px';
+	const threshold = options?.threshold ?? 0;
+
+	return {
+		_s: ({ element, gate, prefetch }) => {
+			const callback = prefetch || (gate as never as VisibleGate).s;
+
+			if (!element) {
+				callback();
+				return;
+			}
+
+			const observer = new IntersectionObserver((entries) => {
+				if (!entries[0]!.isIntersecting) return;
+				observer.disconnect();
+				callback();
+			}, { rootMargin, threshold });
+			observer.observe(element);
+			return () => observer.disconnect();
+		},
+		_h: VisibleHydrate,
+	};
+}

package/src/hydration/visible.tsrx.d.ts

@@ -0,0 +1,12 @@
+import type { OctaneNode } from 'octane';
+import type {
+	HydrationPrefetchStrategy,
+	VisibleHydrationOptions,
+} from '@tanstack/start-client-core/hydration';
+import type { HydrateProps, OctaneHydrationStrategy } from '../Hydrate.tsrx';
+
+export declare function VisibleHydrate(props: HydrateProps): OctaneNode;
+
+export declare function visible(
+	options?: VisibleHydrationOptions,
+): OctaneHydrationStrategy<'visible', true> & HydrationPrefetchStrategy<'visible'>;

package/src/hydration.d.ts

@@ -0,0 +1,20 @@
+export { condition, interaction, media } from './hydration/generic.js';
+export { idle } from './hydration/idle.js';
+export { load } from './hydration/load.tsrx';
+export { never } from './hydration/never.tsrx';
+export { visible } from './hydration/visible.tsrx';
+export type {
+	HydrationCondition,
+	HydrationInteractionEvent,
+	HydrationInteractionEvents,
+	IdleHydrationOptions,
+	HydrationPrefetchContext,
+	HydrationPrefetchFunction,
+	HydrationPrefetchWhen,
+	HydrationPrefetchStrategy,
+	HydrationPrefetchWaitReason,
+	HydrationStrategyTypes,
+	HydrationWhen,
+	VisibleHydrationOptions,
+} from '@tanstack/start-client-core/hydration';
+export type { HydrationStrategy, OctaneHydrationStrategy } from './Hydrate.tsrx';

package/src/hydration.js

@@ -0,0 +1,8 @@
+// `@octanejs/tanstack-start/hydration` — port of @tanstack/react-start's
+// hydration.ts subpath: the hydration strategy factories consumed by
+// `<Hydrate when={...}>`.
+export { condition, interaction, media } from './hydration/generic.js';
+export { idle } from './hydration/idle.js';
+export { load } from './hydration/load.tsrx';
+export { never } from './hydration/never.tsrx';
+export { visible } from './hydration/visible.tsrx';

package/src/index.d.ts

@@ -1,5 +1,16 @@
 export { useServerFn } from './use-server-fn.js';
 export * from '@tanstack/start-client-core';
+export { Hydrate } from './Hydrate.tsrx';
+export type {
+	HydrateOptions,
+	HydrateProps,
+	HydrationInteractionEvent,
+	HydrationInteractionEvents,
+	HydrationPrefetchStrategy,
+	HydrationStrategy,
+	HydrationWhen,
+	OctaneHydrationStrategy,
+} from './Hydrate.tsrx';
 export {
 	createClientOnlyFn,
 	createCsrfMiddleware,

package/src/index.js

@@ -1,4 +1,5 @@
 import { useServerFn } from './use-server-fn.js';
+import { Hydrate } from './Hydrate.tsrx';
 import {
 	createClientOnlyFn,
 	createCsrfMiddleware,
@@ -11,6 +12,7 @@ import {
 
 export * from '@tanstack/start-client-core';
 export {
+	Hydrate,
 	createClientOnlyFn,
 	createCsrfMiddleware,
 	createIsomorphicFn,

package/src/internal/router-generator/filesystem/physical/getRouteNodes.js

@@ -180,12 +180,10 @@ async function getRouteNodes(config, root, tokenRegexes) {
 					}
 					const lastOriginalSegment = originalRoutePath.split('/').filter(Boolean).pop() || '';
 					const indexTokenCandidate = unwrapBracketWrappedSegment(lastOriginalSegment);
-					if (
-						!(
-							lastOriginalSegment !== indexTokenCandidate &&
-							indexTokenSegmentRegex.test(indexTokenCandidate)
-						)
-					) {
+					if (!(
+						lastOriginalSegment !== indexTokenCandidate &&
+						indexTokenSegmentRegex.test(indexTokenCandidate)
+					)) {
 						const updatedRouteSegments = routePath.split('/').filter(Boolean);
 						const updatedLastRouteSegment =
 							updatedRouteSegments[updatedRouteSegments.length - 1] || '';

package/src/internal/router-generator/generator.js

@@ -240,6 +240,9 @@ var Generator = class Generator {
 					} else {
 						const unrecoverableErrors = errArray.filter((e) => !isRerun(e));
 						this.runPromise = void 0;
+						if (process.env.OCTANE_DEBUG_GENERATOR) {
+							for (const e of unrecoverableErrors) console.error('[generator-debug]', e);
+						}
 						throw new Error(unrecoverableErrors.map((e) => e.message).join());
 					}
 				}

package/src/internal/router-plugin/core/code-splitter/compilers.js

@@ -836,12 +836,9 @@ function detectCodeSplitGroupingsFromRoute(opts) {
 				programPath.traverse({
 					CallExpression(path) {
 						if (!t.isIdentifier(path.node.callee)) return;
-						if (
-							!(
-								path.node.callee.name === 'createRoute' ||
-								path.node.callee.name === 'createFileRoute'
-							)
-						)
+						if (!(
+							path.node.callee.name === 'createRoute' || path.node.callee.name === 'createFileRoute'
+						))
 							return;
 						function babelHandleSplittingGroups(routeOptions) {
 							if (t.isObjectExpression(routeOptions))

package/src/internal/router-plugin/core/config.d.ts

@@ -251,9 +251,7 @@ export declare const getConfig: (
 	tmpDir: string;
 	importRoutesUsingAbsolutePaths: boolean;
 	virtualRouteConfig?:
-		| string
-		| import('@tanstack/virtual-file-routes').VirtualRootRoute
-		| undefined;
+		string | import('@tanstack/virtual-file-routes').VirtualRootRoute | undefined;
 	routeFilePrefix?: string | undefined;
 	routeFileIgnorePattern?: string | undefined;
 	pathParamsAllowedCharacters?: (':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[] | undefined;

package/src/internal/router-plugin/esbuild.d.ts

@@ -68,14 +68,11 @@ declare const TanStackRouterEsbuild: (
 						tmpDir: string;
 						importRoutesUsingAbsolutePaths: boolean;
 						virtualRouteConfig?:
-							| string
-							| import('@tanstack/virtual-file-routes').VirtualRootRoute
-							| undefined;
+							string | import('@tanstack/virtual-file-routes').VirtualRootRoute | undefined;
 						routeFilePrefix?: string | undefined;
 						routeFileIgnorePattern?: string | undefined;
 						pathParamsAllowedCharacters?:
-							| (':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[]
-							| undefined;
+							(':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[] | undefined;
 						routeTreeFileFooter?: string[] | (() => Array<string>) | undefined;
 						autoCodeSplitting?: boolean | undefined;
 						customScaffolding?:
@@ -143,14 +140,11 @@ declare const tanstackRouter: (
 						tmpDir: string;
 						importRoutesUsingAbsolutePaths: boolean;
 						virtualRouteConfig?:
-							| string
-							| import('@tanstack/virtual-file-routes').VirtualRootRoute
-							| undefined;
+							string | import('@tanstack/virtual-file-routes').VirtualRootRoute | undefined;
 						routeFilePrefix?: string | undefined;
 						routeFileIgnorePattern?: string | undefined;
 						pathParamsAllowedCharacters?:
-							| (':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[]
-							| undefined;
+							(':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[] | undefined;
 						routeTreeFileFooter?: string[] | (() => Array<string>) | undefined;
 						autoCodeSplitting?: boolean | undefined;
 						customScaffolding?:

package/src/internal/router-plugin/vite.d.ts

@@ -68,14 +68,11 @@ declare const tanstackRouter: (
 						tmpDir: string;
 						importRoutesUsingAbsolutePaths: boolean;
 						virtualRouteConfig?:
-							| string
-							| import('@tanstack/virtual-file-routes').VirtualRootRoute
-							| undefined;
+							string | import('@tanstack/virtual-file-routes').VirtualRootRoute | undefined;
 						routeFilePrefix?: string | undefined;
 						routeFileIgnorePattern?: string | undefined;
 						pathParamsAllowedCharacters?:
-							| (':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[]
-							| undefined;
+							(':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[] | undefined;
 						routeTreeFileFooter?: string[] | (() => Array<string>) | undefined;
 						autoCodeSplitting?: boolean | undefined;
 						customScaffolding?:
@@ -146,14 +143,11 @@ declare const TanStackRouterVite: (
 						tmpDir: string;
 						importRoutesUsingAbsolutePaths: boolean;
 						virtualRouteConfig?:
-							| string
-							| import('@tanstack/virtual-file-routes').VirtualRootRoute
-							| undefined;
+							string | import('@tanstack/virtual-file-routes').VirtualRootRoute | undefined;
 						routeFilePrefix?: string | undefined;
 						routeFileIgnorePattern?: string | undefined;
 						pathParamsAllowedCharacters?:
-							| (':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[]
-							| undefined;
+							(':' | '$' | ';' | '@' | '&' | '=' | '+' | ',')[] | undefined;
 						routeTreeFileFooter?: string[] | (() => Array<string>) | undefined;
 						autoCodeSplitting?: boolean | undefined;
 						customScaffolding?:

package/src/internal/start-plugin-core/import-protection/analysis.js

@@ -72,21 +72,22 @@ function collectIdentifiersFromPattern$1(pattern, add) {
 function isValidExportName(name) {
 	if (name === 'default' || name.length === 0) return false;
 	const first = name.charCodeAt(0);
-	if (
-		!((first >= 65 && first <= 90) || (first >= 97 && first <= 122) || first === 95 || first === 36)
-	)
+	if (!(
+		(first >= 65 && first <= 90) ||
+		(first >= 97 && first <= 122) ||
+		first === 95 ||
+		first === 36
+	))
 		return false;
 	for (let i = 1; i < name.length; i++) {
 		const ch = name.charCodeAt(i);
-		if (
-			!(
-				(ch >= 65 && ch <= 90) ||
-				(ch >= 97 && ch <= 122) ||
-				(ch >= 48 && ch <= 57) ||
-				ch === 95 ||
-				ch === 36
-			)
-		)
+		if (!(
+			(ch >= 65 && ch <= 90) ||
+			(ch >= 97 && ch <= 122) ||
+			(ch >= 48 && ch <= 57) ||
+			ch === 95 ||
+			ch === 36
+		))
 			return false;
 	}
 	return true;

package/src/internal/start-plugin-core/schema.d.ts

@@ -208,8 +208,7 @@ export declare function parseStartConfig(
 		base: string;
 		disableCsrfMiddlewareWarning: boolean;
 		generateFunctionId?:
-			| ((opts: { filename: string; functionName: string }) => string | undefined)
-			| undefined;
+			((opts: { filename: string; functionName: string }) => string | undefined) | undefined;
 	};
 	pages: {
 		path: string;
@@ -218,14 +217,7 @@ export declare function parseStartConfig(
 					exclude?: boolean | undefined;
 					priority?: number | undefined;
 					changefreq?:
-						| 'never'
-						| 'always'
-						| 'hourly'
-						| 'daily'
-						| 'weekly'
-						| 'monthly'
-						| 'yearly'
-						| undefined;
+						'never' | 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | undefined;
 					lastmod?: string | Date | undefined;
 					alternateRefs?:
 						| {
@@ -297,8 +289,7 @@ export declare function parseStartConfig(
 				retryCount?: number | undefined;
 				retryDelay?: number | undefined;
 				onSuccess?:
-					| ((result: { page: z.infer<typeof pageBaseSchema>; html: string }) => unknown)
-					| undefined;
+					((result: { page: z.infer<typeof pageBaseSchema>; html: string }) => unknown) | undefined;
 				headers?: Record<string, string> | undefined;
 		  })
 		| undefined;
@@ -333,8 +324,7 @@ export declare function parseStartConfig(
 					| undefined;
 				mockAccess?: 'error' | 'warn' | 'off' | undefined;
 				onViolation?:
-					| ((violation: unknown) => boolean | void | Promise<boolean | void>)
-					| undefined;
+					((violation: unknown) => boolean | void | Promise<boolean | void>) | undefined;
 				include?: (string | RegExp)[] | undefined;
 				exclude?: (string | RegExp)[] | undefined;
 				client?:

package/src/internal/start-plugin-core/start-compiler/compiler.d.ts

@@ -12,12 +12,7 @@ type Binding = ModuleInfoBinding & {
 };
 type Kind = 'None' | `Root` | `Builder` | LookupKind;
 export type BuiltInLookupKind =
-	| 'ServerFn'
-	| 'Middleware'
-	| 'IsomorphicFn'
-	| 'ServerOnlyFn'
-	| 'ClientOnlyFn'
-	| 'ClientOnlyJSX';
+	'ServerFn' | 'Middleware' | 'IsomorphicFn' | 'ServerOnlyFn' | 'ClientOnlyFn' | 'ClientOnlyJSX';
 export type ExternalLookupKind = `External:${string}`;
 export type LookupKind = BuiltInLookupKind | ExternalLookupKind;
 export declare function getExternalLookupKind(

package/src/internal/start-plugin-core/types.d.ts

@@ -22,8 +22,7 @@ export type SerializationAdapterByRuntime = Partial<
 	Record<SerializationRuntime, SerializationAdapterModuleRef>
 >;
 export type SerializationAdapterConfig =
-	| SerializationAdapterModuleRef
-	| SerializationAdapterByRuntime;
+	SerializationAdapterModuleRef | SerializationAdapterByRuntime;
 export type StartCompilerEnvironment = 'client' | 'server';
 export interface StartCompilerImportTransformImport {
 	libName: string;